From 8ed92e0930a92c498226a22dcb0c1cd27c4dd98f Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Wed, 22 May 2024 14:38:13 +0200 Subject: [PATCH 01/28] Feature: bootloader hint processor Problem: Starkware devs want to use the bootloader with upstream cairo-vm for their own use case. Solution: migrate all hints from our fork of `cairo-vm` and add a `BootloaderHintProcessor` struct that users can then import and add to their own hint processing logic. Limitations: * the tests do not work yet, we need to modify test code that relies on internal cairo-vm test macros. * the bootloader is not yet compiled and provided as part of the library. --- .github/CODEOWNERS | 1 + .github/ISSUE_TEMPLATE/01_BUG_REPORT.md | 21 + .github/ISSUE_TEMPLATE/02_FEATURE_REQUEST.md | 14 + .github/PULL_REQUEST_TEMPLATE.md | 17 + .github/workflows/check.yml | 52 + Cargo.toml | 23 + src/hints/bootloader_hints.rs | 1032 ++++++++++++++++++ src/hints/codes.rs | 213 ++++ src/hints/execute_task_hints.rs | 883 +++++++++++++++ src/hints/fact_topologies.rs | 689 ++++++++++++ src/hints/hint_processor.rs | 115 ++ src/hints/inner_select_builtins.rs | 116 ++ src/hints/load_cairo_pie.rs | 384 +++++++ src/hints/mod.rs | 13 + src/hints/program_hash.rs | 199 ++++ src/hints/program_loader.rs | 345 ++++++ src/hints/select_builtins.rs | 79 ++ src/hints/simple_bootloader_hints.rs | 325 ++++++ src/hints/types.rs | 81 ++ src/hints/vars.rs | 47 + src/lib.rs | 1 + 21 files changed, 4650 insertions(+) create mode 100644 .github/CODEOWNERS create mode 100644 .github/ISSUE_TEMPLATE/01_BUG_REPORT.md create mode 100644 .github/ISSUE_TEMPLATE/02_FEATURE_REQUEST.md create mode 100644 .github/PULL_REQUEST_TEMPLATE.md create mode 100644 .github/workflows/check.yml create mode 100644 Cargo.toml create mode 100644 src/hints/bootloader_hints.rs create mode 100644 src/hints/codes.rs create mode 100644 src/hints/execute_task_hints.rs create mode 100644 src/hints/fact_topologies.rs create mode 100644 src/hints/hint_processor.rs create mode 100644 src/hints/inner_select_builtins.rs create mode 100644 src/hints/load_cairo_pie.rs create mode 100644 src/hints/mod.rs create mode 100644 src/hints/program_hash.rs create mode 100644 src/hints/program_loader.rs create mode 100644 src/hints/select_builtins.rs create mode 100644 src/hints/simple_bootloader_hints.rs create mode 100644 src/hints/types.rs create mode 100644 src/hints/vars.rs create mode 100644 src/lib.rs diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS new file mode 100644 index 0000000..bb0ee86 --- /dev/null +++ b/.github/CODEOWNERS @@ -0,0 +1 @@ +* @odesenfans @notlesh @whichqua diff --git a/.github/ISSUE_TEMPLATE/01_BUG_REPORT.md b/.github/ISSUE_TEMPLATE/01_BUG_REPORT.md new file mode 100644 index 0000000..6d4bea9 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/01_BUG_REPORT.md @@ -0,0 +1,21 @@ +--- +name: Bug Report +about: Create a report to help improve the Cairo bootloader +title: "Problem: " +labels: "bug" +assignees: "" +--- + +**Cairo bootloader version:** + +**Current behavior:** + +**Expected behavior:** + +**Steps to reproduce:** + +**Related code:** + +``` +insert short code snippets here +``` diff --git a/.github/ISSUE_TEMPLATE/02_FEATURE_REQUEST.md b/.github/ISSUE_TEMPLATE/02_FEATURE_REQUEST.md new file mode 100644 index 0000000..b53cd0a --- /dev/null +++ b/.github/ISSUE_TEMPLATE/02_FEATURE_REQUEST.md @@ -0,0 +1,14 @@ +--- +name: Feature Request +about: Suggest an idea for this project +title: "feat: " +labels: "enhancement" +assignees: "" +--- + +**Describe the Feature Request** + +**Related Code** + +**Additional Context** + diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 0000000..739b6ba --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,17 @@ +## Type + +- [ ] feature +- [ ] bugfix +- [ ] dev (no functional changes, no API changes) +- [ ] fmt (formatting, renaming) +- [ ] build +- [ ] docs +- [ ] testing + +## Description + + +## Breaking changes? + +- [ ] yes +- [ ] no diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml new file mode 100644 index 0000000..201207f --- /dev/null +++ b/.github/workflows/check.yml @@ -0,0 +1,52 @@ +name: check + +on: + push: + branches: + - main + pull_request: + +jobs: + rustfmt: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - run: rustup show + - run: rustup component add rustfmt + - uses: Swatinem/rust-cache@v2 + - run: cargo fmt --all -- --check + + clippy: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - run: rustup show + - uses: Swatinem/rust-cache@v2 + - run: cargo clippy --all -- -D warnings + + # tests: + # runs-on: ubuntu-latest + # steps: + # - uses: actions/checkout@v4 + # with: + # submodules: "true" + # - run: rustup show + # - uses: Swatinem/rust-cache@v2 + # - uses: actions/setup-python@v4 + # with: + # python-version: '3.11' + # - run: | + # pip install cairo-lang==0.13.1 + # bash ./scripts/reset-tests.sh + # RUSTFLAGS="-D warnings" cargo test + + udeps: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - run: rustup show + - uses: Swatinem/rust-cache@v2 + with: + cache-on-failure: true + - run: cargo install cargo-udeps --locked + - run: cargo udeps --all-targets diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000..859d9b0 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,23 @@ +[package] +name = "cairo-bootloader" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +cairo-vm = { version = "1.0.0-rc3", features = ["extensive_hints"] } +num-traits = "0.2.19" +serde = { version = "1.0.202", features = ["derive"] } +serde_json = "1.0.117" +starknet-crypto = "0.6.2" +starknet-types-core = "0.1.2" +thiserror = "1.0.61" +thiserror-no-std = "2.0.2" + +[dev-dependencies] +assert_matches = "1.5.0" +rstest = "0.19.0" + +[patch.crates-io] +cairo-vm = { path = "../cairo-vm/vm" } diff --git a/src/hints/bootloader_hints.rs b/src/hints/bootloader_hints.rs new file mode 100644 index 0000000..d54482a --- /dev/null +++ b/src/hints/bootloader_hints.rs @@ -0,0 +1,1032 @@ +use crate::hints::fact_topologies::{ + compute_fact_topologies, configure_fact_topologies, write_to_fact_topologies_file, FactTopology, +}; +use cairo_vm::any_box; +use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{ + get_integer_from_var_name, get_ptr_from_var_name, insert_value_from_var_name, + insert_value_into_ap, +}; +use cairo_vm::hint_processor::hint_processor_definition::HintReference; +use cairo_vm::serde::deserialize_program::ApTracking; +use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::types::relocatable::{MaybeRelocatable, Relocatable}; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::errors::memory_errors::MemoryError; +use cairo_vm::vm::runners::builtin_runner::OutputBuiltinState; +use cairo_vm::vm::vm_core::VirtualMachine; +use num_traits::ToPrimitive; +use std::any::Any; +use std::collections::HashMap; + +use crate::hints::types::{BootloaderInput, CompositePackedOutput, PackedOutput}; +use crate::hints::vars; + +/// Implements +/// %{ +/// from starkware.cairo.bootloaders.bootloader.objects import BootloaderInput +/// bootloader_input = BootloaderInput.Schema().load(program_input) +/// +/// ids.simple_bootloader_output_start = segments.add() +/// +/// # Change output builtin state to a different segment in preparation for calling the +/// # simple bootloader. +/// output_builtin_state = output_builtin.get_state() +/// output_builtin.new_state(base=ids.simple_bootloader_output_start) +/// %} +pub fn prepare_simple_bootloader_output_segment( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + // Python: bootloader_input = BootloaderInput.Schema().load(program_input) + // -> Assert that the bootloader input has been loaded when setting up the VM + let _bootloader_input: &BootloaderInput = exec_scopes.get_ref(vars::BOOTLOADER_INPUT)?; + + // Python: ids.simple_bootloader_output_start = segments.add() + let new_segment_base = vm.add_memory_segment(); + insert_value_from_var_name( + "simple_bootloader_output_start", + new_segment_base, + vm, + ids_data, + ap_tracking, + )?; + + // Python: + // output_builtin_state = output_builtin.get_state() + // output_builtin.new_state(base=ids.simple_bootloader_output_start) + let output_builtin = vm.get_output_builtin_mut()?; + let output_builtin_state = output_builtin.get_state(); + output_builtin.new_state(new_segment_base.segment_index as usize, true); + exec_scopes.insert_value(vars::OUTPUT_BUILTIN_STATE, output_builtin_state); + + insert_value_from_var_name( + "simple_bootloader_output_start", + new_segment_base, + vm, + ids_data, + ap_tracking, + )?; + + Ok(()) +} + +/// Implements %{ simple_bootloader_input = bootloader_input %} +pub fn prepare_simple_bootloader_input(exec_scopes: &mut ExecutionScopes) -> Result<(), HintError> { + let bootloader_input: BootloaderInput = exec_scopes.get(vars::BOOTLOADER_INPUT)?; + exec_scopes.insert_value( + vars::SIMPLE_BOOTLOADER_INPUT, + bootloader_input.simple_bootloader_input, + ); + + Ok(()) +} + +/// Implements +/// # Restore the bootloader's output builtin state. +/// output_builtin.set_state(output_builtin_state) +pub fn restore_bootloader_output( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, +) -> Result<(), HintError> { + let output_builtin_state: OutputBuiltinState = exec_scopes.get(vars::OUTPUT_BUILTIN_STATE)?; + vm.get_output_builtin_mut()?.set_state(output_builtin_state); + + Ok(()) +} +/// Mimics the behaviour of the Python VM `gen_arg`. +/// +/// Creates a new segment for each vector encountered in `args`. For each new +/// segment, the pointer to the segment will be added to the current segment. +/// +/// Example: `vec![1, 2, vec![3, 4]]` +/// -> Allocates segment N, starts writing at offset 0: +/// (N, 0): 1 # Write the values of the vector one by one +/// (N, 1): 2 +/// -> a vector is encountered, allocate a new segment +/// (N, 2): N+1 # Pointer to the new segment +/// (N+1, 0): 3 # Write the values of the nested vector +/// (N+1, 1): 4 +fn gen_arg(vm: &mut VirtualMachine, args: &Vec>) -> Result { + let base = vm.segments.add(); + let mut ptr = base; + + for arg in args { + if let Some(value) = arg.downcast_ref::() { + ptr = vm.segments.load_data(ptr, &vec![value.clone()])?; + } else if let Some(vector) = arg.downcast_ref::>>() { + let nested_base = gen_arg(vm, vector)?; + ptr = vm.segments.load_data(ptr, &vec![nested_base.into()])?; + } else { + return Err(MemoryError::GenArgInvalidType); + } + } + + Ok(base) +} + +/// Implements +/// from starkware.cairo.bootloaders.bootloader.objects import BootloaderConfig +/// bootloader_config: BootloaderConfig = bootloader_input.bootloader_config +/// +/// ids.bootloader_config = segments.gen_arg( +/// [ +/// bootloader_config.simple_bootloader_program_hash, +/// len(bootloader_config.supported_cairo_verifier_program_hashes), +/// bootloader_config.supported_cairo_verifier_program_hashes, +/// ], +/// ) +pub fn load_bootloader_config( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let bootloader_input: BootloaderInput = exec_scopes.get(vars::BOOTLOADER_INPUT)?; + let config = bootloader_input.bootloader_config; + + // Organize args as + // [ + // bootloader_config.simple_bootloader_program_hash, + // len(bootloader_config.supported_cairo_verifier_program_hashes), + // bootloader_config.supported_cairo_verifier_program_hashes, + // ] + let mut program_hashes = Vec::>::new(); + for program_hash in &config.supported_cairo_verifier_program_hashes { + program_hashes.push(Box::new(MaybeRelocatable::from(program_hash))); + } + + let args: Vec> = vec![ + any_box!(config.simple_bootloader_program_hash), + any_box!(config.supported_cairo_verifier_program_hashes), + any_box!(program_hashes), + ]; + + // Store the args in the VM memory + let args_segment = gen_arg(vm, &args)?; + insert_value_from_var_name("bootloader_config", args_segment, vm, ids_data, ap_tracking)?; + + Ok(()) +} + +/// Implements +/// from starkware.cairo.bootloaders.bootloader.objects import PackedOutput +/// +/// task_id = len(packed_outputs) - ids.n_subtasks +/// packed_output: PackedOutput = packed_outputs[task_id] +/// +/// vm_enter_scope(new_scope_locals=dict(packed_output=packed_output)) +pub fn enter_packed_output_scope( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + // task_id = len(packed_outputs) - ids.n_subtasks + let packed_outputs: Vec = exec_scopes.get(vars::PACKED_OUTPUTS)?; + let n_subtasks = get_integer_from_var_name("n_subtasks", vm, ids_data, ap_tracking) + .unwrap() + .to_usize() + .unwrap(); + let task_id = packed_outputs.len() - n_subtasks; + // packed_output: PackedOutput = packed_outputs[task_id] + let packed_output: Box = Box::new(packed_outputs[task_id].clone()); + + // vm_enter_scope(new_scope_locals=dict(packed_output=packed_output)) + exec_scopes.enter_scope(HashMap::from([( + vars::PACKED_OUTPUT.to_string(), + packed_output, + )])); + + Ok(()) +} + +/// Implements +/// from starkware.cairo.bootloaders.bootloader.objects import ( +/// CompositePackedOutput, +/// PlainPackedOutput, +/// ) +pub fn import_packed_output_schemas() -> Result<(), HintError> { + // Nothing to do! + Ok(()) +} + +/// Implements %{ isinstance(packed_output, PlainPackedOutput) %} +/// (compiled to %{ memory[ap] = to_felt_or_relocatable(isinstance(packed_output, PlainPackedOutput)) %}). +/// +/// Stores the result in the `ap` register to be accessed by the program. +pub fn is_plain_packed_output( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, +) -> Result<(), HintError> { + let packed_output: PackedOutput = exec_scopes.get(vars::PACKED_OUTPUT)?; + let result = match packed_output { + PackedOutput::Plain(_) => 1, + _ => 0, + }; + insert_value_into_ap(vm, result)?; + + Ok(()) +} + +/// Implements +/// %{ assert isinstance(packed_output, CompositePackedOutput) %} +pub fn assert_is_composite_packed_output( + exec_scopes: &mut ExecutionScopes, +) -> Result<(), HintError> { + let packed_output: PackedOutput = exec_scopes.get(vars::PACKED_OUTPUT)?; + + match packed_output { + PackedOutput::Composite(_) => Ok(()), + other => Err(HintError::CustomHint( + format!("Expected composite packed output, got {:?}", other).into_boxed_str(), + )), + } +} + +/* +Implements hint: +%{ + output_start = ids.output_ptr +%} +*/ +pub fn save_output_pointer( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let output_ptr = get_ptr_from_var_name("output_ptr", vm, ids_data, ap_tracking)?; + exec_scopes.insert_value(vars::OUTPUT_START, output_ptr); + Ok(()) +} + +/* +Implements hint: +%{ + packed_outputs = bootloader_input.packed_outputs +%} +*/ +pub fn save_packed_outputs(exec_scopes: &mut ExecutionScopes) -> Result<(), HintError> { + let bootloader_input: &BootloaderInput = exec_scopes.get_ref("bootloader_input")?; + let packed_outputs = bootloader_input.packed_outputs.clone(); + exec_scopes.insert_value("packed_outputs", packed_outputs); + Ok(()) +} + +/// Implements +/// from starkware.cairo.bootloaders.bootloader.utils import compute_fact_topologies +/// from starkware.cairo.bootloaders.fact_topology import FactTopology +/// from starkware.cairo.bootloaders.simple_bootloader.utils import ( +/// configure_fact_topologies, +/// write_to_fact_topologies_file, +/// ) +/// +/// # Compute the fact topologies of the plain packed outputs based on packed_outputs and +/// # fact_topologies of the inner tasks. +/// plain_fact_topologies: List[FactTopology] = compute_fact_topologies( +/// packed_outputs=packed_outputs, fact_topologies=fact_topologies, +/// ) +/// +/// # Configure the memory pages in the output builtin, based on plain_fact_topologies. +/// configure_fact_topologies( +/// fact_topologies=plain_fact_topologies, output_start=output_start, +/// output_builtin=output_builtin, +/// ) +/// +/// # Dump fact topologies to a json file. +/// if bootloader_input.fact_topologies_path is not None: +/// write_to_fact_topologies_file( +/// fact_topologies_path=bootloader_input.fact_topologies_path, +/// fact_topologies=plain_fact_topologies, +/// ) +pub fn compute_and_configure_fact_topologies( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, +) -> Result<(), HintError> { + let packed_outputs: Vec = exec_scopes.get(vars::PACKED_OUTPUTS)?; + let fact_topologies: Vec = exec_scopes.get(vars::FACT_TOPOLOGIES)?; + let mut output_start: Relocatable = exec_scopes.get(vars::OUTPUT_START)?; + let output_builtin = vm.get_output_builtin_mut()?; + + let plain_fact_topologies = compute_fact_topologies(&packed_outputs, &fact_topologies) + .map_err(Into::::into)?; + + configure_fact_topologies(&plain_fact_topologies, &mut output_start, output_builtin) + .map_err(Into::::into)?; + + exec_scopes.insert_value(vars::OUTPUT_START, output_start); + + let bootloader_input: &BootloaderInput = exec_scopes.get_ref(vars::BOOTLOADER_INPUT)?; + if let Some(path) = &bootloader_input + .simple_bootloader_input + .fact_topologies_path + { + write_to_fact_topologies_file(path.as_path(), &plain_fact_topologies) + .map_err(Into::::into)?; + } + + Ok(()) +} + +fn unwrap_composite_output( + packed_output: PackedOutput, +) -> Result { + match packed_output { + PackedOutput::Plain(_) => Err(HintError::CustomHint( + "Expected packed output to be composite" + .to_string() + .into_boxed_str(), + )), + PackedOutput::Composite(composite_packed_output) => Ok(composite_packed_output), + } +} + +/* +Implements hint: +%{ + packed_outputs = packed_output.subtasks +%} +*/ +pub fn set_packed_output_to_subtasks(exec_scopes: &mut ExecutionScopes) -> Result<(), HintError> { + let packed_output: PackedOutput = exec_scopes.get(vars::PACKED_OUTPUT)?; + let composite_packed_output = unwrap_composite_output(packed_output)?; + let subtasks = composite_packed_output.subtasks; + exec_scopes.insert_value(vars::PACKED_OUTPUTS, subtasks); + + Ok(()) +} + +/* +Implements hint: +%{ + data = packed_output.elements_for_hash() + ids.nested_subtasks_output_len = len(data) + ids.nested_subtasks_output = segments.gen_arg(data)"; +%} +*/ +pub fn guess_pre_image_of_subtasks_output_hash( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let packed_output: PackedOutput = exec_scopes.get(vars::PACKED_OUTPUT)?; + let composite_packed_output = unwrap_composite_output(packed_output)?; + + let data = composite_packed_output.elements_for_hash(); + insert_value_from_var_name( + "nested_subtasks_output_len", + data.len(), + vm, + ids_data, + ap_tracking, + )?; + let args = data + .iter() + .cloned() + .map(|x| Box::new(MaybeRelocatable::Int(x)) as Box) + .collect(); + let nested_subtasks_output = gen_arg(vm, &args)?; + insert_value_from_var_name( + "nested_subtasks_output", + nested_subtasks_output, + vm, + ids_data, + ap_tracking, + )?; + + Ok(()) +} + +/* +Implements hint: +%{ + # Sanity check. + assert ids.program_address == program_address" +%} +*/ +pub fn assert_program_address( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let ids_program_address = + get_ptr_from_var_name(vars::PROGRAM_ADDRESS, vm, ids_data, ap_tracking)?; + let program_address: Relocatable = exec_scopes.get(vars::PROGRAM_ADDRESS)?; + + if ids_program_address != program_address { + return Err(HintError::CustomHint( + "program address is incorrect".to_string().into_boxed_str(), + )); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use num_traits::ToPrimitive; + + use crate::hints::types::{BootloaderConfig, SimpleBootloaderInput}; + use assert_matches::assert_matches; + use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::{ + BuiltinHintProcessor, HintProcessorData, + }; + use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_maybe_relocatable_from_var_name; + use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; + use cairo_vm::serde::deserialize_program::OffsetValue; + use cairo_vm::vm::runners::builtin_runner::{BuiltinRunner, OutputBuiltinState}; + use cairo_vm::vm::runners::cairo_pie::PublicMemoryPage; + use cairo_vm::{any_box, relocatable, Felt252}; + use rstest::{fixture, rstest}; + + use super::*; + + #[fixture] + fn bootloader_input() -> BootloaderInput { + BootloaderInput { + simple_bootloader_input: SimpleBootloaderInput { + fact_topologies_path: None, + single_page: false, + tasks: vec![], + }, + bootloader_config: BootloaderConfig { + simple_bootloader_program_hash: Felt252::from(1234), + supported_cairo_verifier_program_hashes: vec![ + Felt252::from(5678), + Felt252::from(8765), + ], + }, + packed_outputs: vec![], + } + } + + #[rstest] + fn test_prepare_simple_bootloader_output_segment(bootloader_input: BootloaderInput) { + let mut vm = vm!(); + vm.segments.add(); + vm.run_context.fp = 1; + + let mut output_builtin = OutputBuiltinRunner::new(true); + output_builtin.initialize_segments(&mut vm.segments); + vm.builtin_runners + .push(BuiltinRunner::Output(output_builtin.clone())); + + let mut exec_scopes = ExecutionScopes::new(); + let ids_data = ids_data!["simple_bootloader_output_start"]; + let ap_tracking = ApTracking::new(); + + exec_scopes.insert_value(vars::BOOTLOADER_INPUT, bootloader_input); + prepare_simple_bootloader_output_segment( + &mut vm, + &mut exec_scopes, + &ids_data, + &ap_tracking, + ) + .expect("Hint failed unexpectedly"); + + let current_output_builtin = vm + .get_output_builtin() + .expect("The VM should have an output builtin") + .clone(); + let stored_output_builtin: OutputBuiltinState = exec_scopes + .get(vars::OUTPUT_BUILTIN_STATE) + .expect("The output builtin is not stored in the execution scope as expected"); + + // Check the content of the stored output builtin + assert_ne!(current_output_builtin.base(), stored_output_builtin.base()); + assert_eq!(stored_output_builtin.base(), output_builtin.base()); + assert_eq!(stored_output_builtin.stop_ptr, output_builtin.stop_ptr); + assert_eq!(stored_output_builtin.included, output_builtin.included); + + let simple_bootloader_output_start = get_maybe_relocatable_from_var_name( + "simple_bootloader_output_start", + &vm, + &ids_data, + &ap_tracking, + ) + .expect("Simple bootloader output start not accessible from program IDs"); + assert!( + matches!(simple_bootloader_output_start, MaybeRelocatable::RelocatableValue(relocatable) if relocatable.segment_index == current_output_builtin.base() as isize) + ); + } + + #[test] + fn test_prepare_simple_bootloader_output_segment_missing_input() { + let mut vm = vm!(); + let mut exec_scopes = ExecutionScopes::new(); + let ids_data = HashMap::::new(); + let ap_tracking = ApTracking::default(); + + let result = prepare_simple_bootloader_output_segment( + &mut vm, + &mut exec_scopes, + &ids_data, + &ap_tracking, + ); + let hint_error = + result.expect_err("Hint should fail, the bootloader input variable is not set"); + assert!( + matches!(hint_error, HintError::VariableNotInScopeError(s) if s == vars::BOOTLOADER_INPUT.into()) + ); + } + #[rstest] + fn test_prepare_simple_bootloader_input(bootloader_input: BootloaderInput) { + let mut exec_scopes = ExecutionScopes::new(); + exec_scopes.insert_value(vars::BOOTLOADER_INPUT, bootloader_input.clone()); + + prepare_simple_bootloader_input(&mut exec_scopes).expect("Hint failed unexpectedly"); + + let simple_bootloader_input: SimpleBootloaderInput = exec_scopes + .get(vars::SIMPLE_BOOTLOADER_INPUT) + .expect("Simple bootloader input not in scope"); + assert_eq!( + simple_bootloader_input, + bootloader_input.simple_bootloader_input + ); + } + + #[test] + fn test_restore_bootloader_output() { + let mut vm: VirtualMachine = vm!(); + // The VM must have an existing output segment + let output_segment = vm.add_memory_segment(); + vm.builtin_runners = vec![OutputBuiltinRunner::from_segment(&output_segment, true).into()]; + + let mut exec_scopes = ExecutionScopes::new(); + let new_segment = vm.add_memory_segment(); + let output_builtin_state = OutputBuiltinState { + base: new_segment.segment_index, + pages: Default::default(), + attributes: Default::default(), + }; + exec_scopes.insert_value(vars::OUTPUT_BUILTIN_STATE, output_builtin_state.clone()); + + restore_bootloader_output(&mut vm, &mut exec_scopes).expect("Error while executing hint"); + + assert_eq!(vm.builtin_runners.len(), 1); + match &vm.builtin_runners[0] { + BuiltinRunner::Output(output_builtin) => { + assert_eq!(output_builtin.base(), output_builtin_state.base()); + } + other => panic!("Expected an output builtin, found {:?}", other), + } + } + + #[rstest] + fn test_load_bootloader_config(bootloader_input: BootloaderInput) { + let config = bootloader_input.bootloader_config.clone(); + + let mut vm = vm!(); + add_segments!(vm, 2); + vm.run_context.fp = 2; + + let mut exec_scopes = ExecutionScopes::new(); + let ids_data = ids_data!["bootloader_config"]; + let ap_tracking = ApTracking::new(); + + exec_scopes.insert_value(vars::BOOTLOADER_INPUT, bootloader_input); + + load_bootloader_config(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Bootloader hint failed unexpectedly"); + + let bootloader_config_segment = + get_ptr_from_var_name("bootloader_config", &mut vm, &ids_data, &ap_tracking).unwrap(); + + let config_segment = vm + .segments + .memory + .get_continuous_range(bootloader_config_segment, 3) + .unwrap(); + + // Assert that the values in the config segment match + let bootloader_hash = &config_segment[0]; + assert!( + matches!(bootloader_hash, MaybeRelocatable::Int(x) if *x == config.simple_bootloader_program_hash) + ); + + let nb_programs = &config_segment[1]; + let expected_nb_programs = config.supported_cairo_verifier_program_hashes.len(); + assert!( + matches!(nb_programs, MaybeRelocatable::Int(x) if x.to_usize().unwrap() == expected_nb_programs) + ); + + // Assert that the values in the programs segment match + let programs_segment = &config_segment[2]; + match programs_segment { + MaybeRelocatable::RelocatableValue(relocatable) => { + let program_hashes: Vec = vm + .segments + .memory + .get_integer_range(relocatable.clone(), expected_nb_programs) + .unwrap() + .iter() + .map(|cow| cow.clone().into_owned()) + .collect(); + + assert_eq!( + program_hashes, + config.supported_cairo_verifier_program_hashes + ); + } + other => { + panic!("Expected a pointer to another segment, got {:?}", other); + } + } + } + + #[rstest] + fn test_gen_arg() { + let mut vm = vm!(); + + let mut nested_args = Vec::>::new(); + nested_args.push(Box::new(MaybeRelocatable::from(128))); + nested_args.push(Box::new(MaybeRelocatable::from(42))); + + let mut args = Vec::>::new(); + args.push(Box::new(MaybeRelocatable::from(1001))); + args.push(Box::new(MaybeRelocatable::from(2048))); + args.push(Box::new(nested_args)); + + let args_base: Relocatable = gen_arg(&mut vm, &args).expect("gen_args failed unexpectedly"); + + let values = vm + .segments + .memory + .get_integer_range(args_base, 2) + .expect("Loading values failed"); + + assert_eq!(*values[0], 1001.into()); + assert_eq!(*values[1], 2048.into()); + + let nested_args_address: Relocatable = args_base.add(2i32).unwrap(); + let nested_args_base = vm + .segments + .memory + .get_relocatable(nested_args_address) + .expect("Nested vector should be here"); + + let nested_values = vm + .segments + .memory + .get_integer_range(nested_args_base, 2) + .expect("Loading nested values failed"); + + assert_eq!(*nested_values[0], 128.into()); + assert_eq!(*nested_values[1], 42.into()); + } + + #[rstest] + fn test_enter_packed_output_scope() { + let mut vm = vm!(); + // Set n_subtasks to 2 + vm.run_context.fp = 1; + vm.segments = segments![((1, 0), 2)]; + let ids_data = ids_data!["n_subtasks"]; + + let ap_tracking = ApTracking::default(); + + let mut exec_scopes = ExecutionScopes::new(); + + let packed_outputs = vec![ + PackedOutput::Plain(vec![]), + PackedOutput::Composite(CompositePackedOutput::default()), + PackedOutput::Plain(vec![]), + ]; + exec_scopes.insert_value(vars::PACKED_OUTPUTS, packed_outputs); + + enter_packed_output_scope(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Hint failed unexpectedly"); + + // Check that we entered a new scope + assert_eq!(exec_scopes.data.len(), 2); + assert_eq!(exec_scopes.data[1].len(), 1); + + let packed_output = exec_scopes + .get(vars::PACKED_OUTPUT) + .expect("PACKED_OUTPUT not present in scope"); + + assert!(matches!(packed_output, PackedOutput::Composite(_))); + } + + #[test] + fn test_is_plain_packed_output() { + let mut vm = vm!(); + add_segments!(vm, 2); + + let mut exec_scopes = ExecutionScopes::new(); + + fn is_plain( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + packed_output: PackedOutput, + ) -> bool { + exec_scopes.insert_value(vars::PACKED_OUTPUT, packed_output); + is_plain_packed_output(vm, exec_scopes).expect("Hint failed unexpectedly"); + let result = vm + .segments + .memory + .get_integer(vm.run_context.get_ap()) + .unwrap(); + + result.into_owned() != Felt252::from(0) + } + + let plain_packed_output = PackedOutput::Plain(Vec::::new()); + let composite_packed_output = PackedOutput::Composite(CompositePackedOutput::default()); + + assert!(is_plain(&mut vm, &mut exec_scopes, plain_packed_output)); + + // Increment AP to avoid an inconsistent memory error writing in the same slot + vm.run_context.ap += 1; + assert!(!is_plain( + &mut vm, + &mut exec_scopes, + composite_packed_output + )); + } + + #[test] + fn test_save_output_pointer() { + let mut vm = vm!(); + vm.segments = segments![((1, 0), (0, 0))]; + let mut hint_ref = HintReference::new(0, 0, true, false); + hint_ref.offset2 = OffsetValue::Value(2); + let ids_data = HashMap::from([("output_ptr".to_string(), hint_ref)]); + + let mut exec_scopes = ExecutionScopes::new(); + + let hint_data = HintProcessorData::new_default( + String::from(hint_code::BOOTLOADER_SAVE_OUTPUT_POINTER), + ids_data, + ); + let mut hint_processor = BuiltinHintProcessor::new_empty(); + assert_matches!( + hint_processor.execute_hint( + &mut vm, + &mut exec_scopes, + &any_box!(hint_data), + &HashMap::new(), + ), + Ok(()) + ); + + let output_ptr = exec_scopes.get::("output_start"); + assert_matches!( + output_ptr, + Ok(x) if x == relocatable!(0, 2) + ); + } + + #[test] + fn test_save_packed_outputs() { + let packed_outputs = vec![ + PackedOutput::Plain(Default::default()), + PackedOutput::Plain(Default::default()), + PackedOutput::Plain(Default::default()), + ]; + + let bootloader_input = BootloaderInput { + simple_bootloader_input: SimpleBootloaderInput { + fact_topologies_path: None, + single_page: false, + tasks: vec![], + }, + bootloader_config: BootloaderConfig { + simple_bootloader_program_hash: 42u64.into(), + supported_cairo_verifier_program_hashes: Default::default(), + }, + packed_outputs: packed_outputs.clone(), + }; + + let mut vm = vm!(); + let mut exec_scopes = ExecutionScopes::new(); + + exec_scopes.insert_box("bootloader_input", Box::new(bootloader_input.clone())); + + let hint_data = HintProcessorData::new_default( + String::from(hint_code::BOOTLOADER_SAVE_PACKED_OUTPUTS), + HashMap::new(), + ); + let mut hint_processor = BuiltinHintProcessor::new_empty(); + assert_matches!( + hint_processor.execute_hint( + &mut vm, + &mut exec_scopes, + &any_box!(hint_data), + &HashMap::new(), + ), + Ok(()) + ); + + let saved_packed_outputs = exec_scopes.get::>("packed_outputs"); + assert_matches!( + saved_packed_outputs, + Ok(ref x) if x == &packed_outputs + ); + + assert_eq!( + saved_packed_outputs.expect("asserted Ok above, qed").len(), + 3 + ); + } + + #[rstest] + fn test_compute_and_configure_fact_topologies(bootloader_input: BootloaderInput) { + let mut vm = vm!(); + let mut output_builtin = OutputBuiltinRunner::new(true); + output_builtin.initialize_segments(&mut vm.segments); + vm.builtin_runners + .push(BuiltinRunner::Output(output_builtin.clone())); + + let mut exec_scopes = ExecutionScopes::new(); + let packed_outputs = vec![PackedOutput::Plain(vec![]), PackedOutput::Plain(vec![])]; + let fact_topologies = vec![ + FactTopology { + tree_structure: vec![], + page_sizes: vec![3usize, 1usize], + }, + FactTopology { + tree_structure: vec![], + page_sizes: vec![10usize], + }, + ]; + let output_start = Relocatable { + segment_index: output_builtin.base() as isize, + offset: 0, + }; + exec_scopes.insert_value(vars::BOOTLOADER_INPUT, bootloader_input); + exec_scopes.insert_value(vars::PACKED_OUTPUTS, packed_outputs); + exec_scopes.insert_value(vars::FACT_TOPOLOGIES, fact_topologies); + exec_scopes.insert_value(vars::OUTPUT_START, output_start); + + compute_and_configure_fact_topologies(&mut vm, &mut exec_scopes) + .expect("Hint failed unexpectedly"); + + let output_start: Relocatable = exec_scopes.get(vars::OUTPUT_START).unwrap(); + assert_eq!( + output_start, + Relocatable { + segment_index: 0, + offset: 18 + } + ); + assert_eq!( + vm.get_output_builtin().unwrap().pages, + HashMap::from([ + (1, PublicMemoryPage { start: 2, size: 3 }), + (2, PublicMemoryPage { start: 5, size: 1 }), + (3, PublicMemoryPage { start: 8, size: 10 }), + ]) + ); + } + + #[test] + fn test_set_packed_output_to_subtasks() { + let mut vm = vm!(); + let mut exec_scopes = ExecutionScopes::new(); + + let subtasks = vec![ + PackedOutput::Plain(vec![]), + PackedOutput::Composite(CompositePackedOutput::default()), + ]; + exec_scopes.insert_value( + vars::PACKED_OUTPUT, + PackedOutput::Composite(CompositePackedOutput { + outputs: vec![], + subtasks: subtasks.clone(), + }), + ); + + let hint_data = HintProcessorData::new_default( + String::from(hint_code::BOOTLOADER_SET_PACKED_OUTPUT_TO_SUBTASKS), + HashMap::new(), + ); + let mut hint_processor = BuiltinHintProcessor::new_empty(); + assert_matches!( + hint_processor.execute_hint( + &mut vm, + &mut exec_scopes, + &any_box!(hint_data), + &HashMap::new(), + ), + Ok(()) + ); + + let packed_outputs: Vec = exec_scopes.get(vars::PACKED_OUTPUTS).unwrap(); + assert_eq!(packed_outputs, subtasks); + } + + #[test] + fn test_guess_pre_image_of_subtasks_output_hash() { + let mut vm = vm!(); + add_segments!(vm, 2); + vm.run_context.fp = 2; + + let ids_data = ids_data!["nested_subtasks_output_len", "nested_subtasks_output"]; + + let mut exec_scopes = ExecutionScopes::new(); + + exec_scopes.insert_box( + "packed_output", + Box::new(PackedOutput::Composite(CompositePackedOutput { + outputs: vec![Felt252::from(42)], + subtasks: vec![], + })), + ); + + let ap_tracking = ApTracking::new(); + + assert_matches!( + run_hint!( + vm, + ids_data.clone(), + hint_code::BOOTLOADER_GUESS_PRE_IMAGE_OF_SUBTASKS_OUTPUT_HASH, + &mut exec_scopes + ), + Ok(()) + ); + let nested_subtasks_output_len = + get_integer_from_var_name("nested_subtasks_output_len", &vm, &ids_data, &ap_tracking) + .expect("nested_subtasks_output_len should be set") + .into_owned(); + assert_eq!(nested_subtasks_output_len, 1.into()); + + let nested_subtasks_output = + get_ptr_from_var_name("nested_subtasks_output", &vm, &ids_data, &ap_tracking) + .expect("nested_subtasks_output should be set"); + let arg = vm.get_integer(nested_subtasks_output).unwrap().into_owned(); + assert_eq!(arg, Felt252::from(42)); + } + + #[rstest] + fn test_assert_is_composite_packed_output() { + let mut exec_scopes = ExecutionScopes::new(); + + let plain_packed_output = PackedOutput::Plain(Vec::::new()); + exec_scopes.insert_value(vars::PACKED_OUTPUT, plain_packed_output); + assert!(matches!( + assert_is_composite_packed_output(&mut exec_scopes), + Err(HintError::CustomHint(_)) + )); + + let composite_packed_output = PackedOutput::Composite(CompositePackedOutput::default()); + exec_scopes.insert_value(vars::PACKED_OUTPUT, composite_packed_output); + assert!(assert_is_composite_packed_output(&mut exec_scopes).is_ok()); + } + + #[rstest] + #[case(false)] + #[case(true)] + fn test_assert_program_address(#[case] expect_fail: bool) { + let mut vm = vm!(); + + add_segments!(vm, 2); + vm.run_context.fp = 2; + + let ids_data = ids_data!(vars::PROGRAM_ADDRESS); + let ap_tracking = ApTracking::new(); + + let mut ptr = Relocatable { + segment_index: 42, + offset: 42, + }; + let _ = insert_value_from_var_name( + vars::PROGRAM_ADDRESS, + ptr.clone(), + &mut vm, + &ids_data, + &ap_tracking, + ) + .map_err(|e| panic!("could not insert var: {}", e)); + + if expect_fail { + ptr = Relocatable { + segment_index: 1, + offset: 1, + }; + } + + let mut exec_scopes = ExecutionScopes::new(); + exec_scopes.insert_box(vars::PROGRAM_ADDRESS, any_box!(ptr)); + + let result = run_hint!( + vm, + ids_data.clone(), + hint_code::EXECUTE_TASK_ASSERT_PROGRAM_ADDRESS, + &mut exec_scopes + ); + + match result { + Ok(_) => assert!(!expect_fail), + Err(HintError::CustomHint(e)) => { + assert!(expect_fail); + assert_eq!(e.as_ref(), "program address is incorrect"); + () + } + _ => panic!("result not recognized"), + } + } +} diff --git a/src/hints/codes.rs b/src/hints/codes.rs new file mode 100644 index 0000000..7c1b346 --- /dev/null +++ b/src/hints/codes.rs @@ -0,0 +1,213 @@ +pub const BOOTLOADER_PREPARE_SIMPLE_BOOTLOADER_OUTPUT_SEGMENT: &str = + "from starkware.cairo.bootloaders.bootloader.objects import BootloaderInput +bootloader_input = BootloaderInput.Schema().load(program_input) + +ids.simple_bootloader_output_start = segments.add() + +# Change output builtin state to a different segment in preparation for calling the +# simple bootloader. +output_builtin_state = output_builtin.get_state() +output_builtin.new_state(base=ids.simple_bootloader_output_start)"; + +pub const BOOTLOADER_PREPARE_SIMPLE_BOOTLOADER_INPUT: &str = + "simple_bootloader_input = bootloader_input"; + +pub const BOOTLOADER_RESTORE_BOOTLOADER_OUTPUT: &str = + "# Restore the bootloader's output builtin state. +output_builtin.set_state(output_builtin_state)"; + +pub const BOOTLOADER_LOAD_BOOTLOADER_CONFIG: &str = + "from starkware.cairo.bootloaders.bootloader.objects import BootloaderConfig +bootloader_config: BootloaderConfig = bootloader_input.bootloader_config + +ids.bootloader_config = segments.gen_arg( + [ + bootloader_config.simple_bootloader_program_hash, + len(bootloader_config.supported_cairo_verifier_program_hashes), + bootloader_config.supported_cairo_verifier_program_hashes, + ], +)"; + +pub const BOOTLOADER_ENTER_PACKED_OUTPUT_SCOPE: &str = + "from starkware.cairo.bootloaders.bootloader.objects import PackedOutput + +task_id = len(packed_outputs) - ids.n_subtasks +packed_output: PackedOutput = packed_outputs[task_id] + +vm_enter_scope(new_scope_locals=dict(packed_output=packed_output))"; + +pub const BOOTLOADER_IMPORT_PACKED_OUTPUT_SCHEMAS: &str = + "from starkware.cairo.bootloaders.bootloader.objects import ( + CompositePackedOutput, + PlainPackedOutput, +)"; + +// Appears as nondet %{ isinstance(packed_output, PlainPackedOutput) %} in the code. +pub const BOOTLOADER_IS_PLAIN_PACKED_OUTPUT: &str = + "memory[ap] = to_felt_or_relocatable(isinstance(packed_output, PlainPackedOutput))"; + +pub const BOOTLOADER_SAVE_OUTPUT_POINTER: &str = "output_start = ids.output_ptr"; + +pub const BOOTLOADER_SAVE_PACKED_OUTPUTS: &str = "packed_outputs = bootloader_input.packed_outputs"; + +pub const BOOTLOADER_COMPUTE_FACT_TOPOLOGIES: &str = "from typing import List + +from starkware.cairo.bootloaders.bootloader.utils import compute_fact_topologies +from starkware.cairo.bootloaders.fact_topology import FactTopology +from starkware.cairo.bootloaders.simple_bootloader.utils import ( + configure_fact_topologies, + write_to_fact_topologies_file, +) + +# Compute the fact topologies of the plain packed outputs based on packed_outputs and +# fact_topologies of the inner tasks. +plain_fact_topologies: List[FactTopology] = compute_fact_topologies( + packed_outputs=packed_outputs, fact_topologies=fact_topologies, +) + +# Configure the memory pages in the output builtin, based on plain_fact_topologies. +configure_fact_topologies( + fact_topologies=plain_fact_topologies, output_start=output_start, + output_builtin=output_builtin, +) + +# Dump fact topologies to a json file. +if bootloader_input.fact_topologies_path is not None: + write_to_fact_topologies_file( + fact_topologies_path=bootloader_input.fact_topologies_path, + fact_topologies=plain_fact_topologies, + )"; + +pub const BOOTLOADER_GUESS_PRE_IMAGE_OF_SUBTASKS_OUTPUT_HASH: &str = + "data = packed_output.elements_for_hash() +ids.nested_subtasks_output_len = len(data) +ids.nested_subtasks_output = segments.gen_arg(data)"; + +pub const BOOTLOADER_SET_PACKED_OUTPUT_TO_SUBTASKS: &str = + "packed_outputs = packed_output.subtasks"; + +pub const BOOTLOADER_ASSERT_IS_COMPOSITE_PACKED_OUTPUT: &str = + "assert isinstance(packed_output, CompositePackedOutput)"; + +pub const SIMPLE_BOOTLOADER_PREPARE_TASK_RANGE_CHECKS: &str = + "n_tasks = len(simple_bootloader_input.tasks) +memory[ids.output_ptr] = n_tasks + +# Task range checks are located right after simple bootloader validation range checks, and +# this is validated later in this function. +ids.task_range_check_ptr = ids.range_check_ptr + ids.BuiltinData.SIZE * n_tasks + +# A list of fact_toplogies that instruct how to generate the fact from the program output +# for each task. +fact_topologies = []"; + +pub const SIMPLE_BOOTLOADER_SET_TASKS_VARIABLE: &str = "tasks = simple_bootloader_input.tasks"; + +// Appears as nondet %{ ids.num // 2 %} in the code. +pub const SIMPLE_BOOTLOADER_DIVIDE_NUM_BY_2: &str = + "memory[ap] = to_felt_or_relocatable(ids.num // 2)"; + +pub const SIMPLE_BOOTLOADER_SET_CURRENT_TASK: &str = + "from starkware.cairo.bootloaders.simple_bootloader.objects import Task + +# Pass current task to execute_task. +task_id = len(simple_bootloader_input.tasks) - ids.n_tasks +task = simple_bootloader_input.tasks[task_id].load_task()"; + +// Appears as nondet %{ 0 %} in the code. +pub const SIMPLE_BOOTLOADER_ZERO: &str = "memory[ap] = to_felt_or_relocatable(0)"; + +pub const EXECUTE_TASK_ALLOCATE_PROGRAM_DATA_SEGMENT: &str = + "ids.program_data_ptr = program_data_base = segments.add()"; + +pub const EXECUTE_TASK_LOAD_PROGRAM: &str = + "from starkware.cairo.bootloaders.simple_bootloader.utils import load_program + +# Call load_program to load the program header and code to memory. +program_address, program_data_size = load_program( + task=task, memory=memory, program_header=ids.program_header, + builtins_offset=ids.ProgramHeader.builtin_list) +segments.finalize(program_data_base.segment_index, program_data_size)"; + +pub const EXECUTE_TASK_VALIDATE_HASH: &str = "# Validate hash. +from starkware.cairo.bootloaders.hash_program import compute_program_hash_chain + +assert memory[ids.output_ptr + 1] == compute_program_hash_chain(task.get_program()), \\ + 'Computed hash does not match input.'"; + +pub const EXECUTE_TASK_ASSERT_PROGRAM_ADDRESS: &str = "# Sanity check. +assert ids.program_address == program_address"; + +pub const EXECUTE_TASK_CALL_TASK: &str = + "from starkware.cairo.bootloaders.simple_bootloader.objects import ( + CairoPieTask, + RunProgramTask, + Task, +) +from starkware.cairo.bootloaders.simple_bootloader.utils import ( + load_cairo_pie, + prepare_output_runner, +) + +assert isinstance(task, Task) +n_builtins = len(task.get_program().builtins) +new_task_locals = {} +if isinstance(task, RunProgramTask): + new_task_locals['program_input'] = task.program_input + new_task_locals['WITH_BOOTLOADER'] = True + + vm_load_program(task.program, program_address) +elif isinstance(task, CairoPieTask): + ret_pc = ids.ret_pc_label.instruction_offset_ - ids.call_task.instruction_offset_ + pc + load_cairo_pie( + task=task.cairo_pie, memory=memory, segments=segments, + program_address=program_address, execution_segment_address= ap - n_builtins, + builtin_runners=builtin_runners, ret_fp=fp, ret_pc=ret_pc) +else: + raise NotImplementedError(f'Unexpected task type: {type(task).__name__}.') + +output_runner_data = prepare_output_runner( + task=task, + output_builtin=output_builtin, + output_ptr=ids.pre_execution_builtin_ptrs.output) +vm_enter_scope(new_task_locals)"; + +pub const EXECUTE_TASK_EXIT_SCOPE: &str = "vm_exit_scope() +# Note that bootloader_input will only be available in the next hint."; + +pub const EXECUTE_TASK_WRITE_RETURN_BUILTINS: &str = + "from starkware.cairo.bootloaders.simple_bootloader.utils import write_return_builtins + +# Fill the values of all builtin pointers after executing the task. +builtins = task.get_program().builtins +write_return_builtins( + memory=memory, return_builtins_addr=ids.return_builtin_ptrs.address_, + used_builtins=builtins, used_builtins_addr=ids.used_builtins_addr, + pre_execution_builtins_addr=ids.pre_execution_builtin_ptrs.address_, task=task) + +vm_enter_scope({'n_selected_builtins': n_builtins})"; + +pub const EXECUTE_TASK_APPEND_FACT_TOPOLOGIES: &str = + "from starkware.cairo.bootloaders.simple_bootloader.utils import get_task_fact_topology + +# Add the fact topology of the current task to 'fact_topologies'. +output_start = ids.pre_execution_builtin_ptrs.output +output_end = ids.return_builtin_ptrs.output +fact_topologies.append(get_task_fact_topology( + output_size=output_end - output_start, + task=task, + output_builtin=output_builtin, + output_runner_data=output_runner_data, +))"; + +pub const SELECT_BUILTINS_ENTER_SCOPE: &str = + "vm_enter_scope({'n_selected_builtins': ids.n_selected_builtins})"; + +pub const INNER_SELECT_BUILTINS_SELECT_BUILTIN: &str = + "# A builtin should be selected iff its encoding appears in the selected encodings list +# and the list wasn't exhausted. +# Note that testing inclusion by a single comparison is possible since the lists are sorted. +ids.select_builtin = int( + n_selected_builtins > 0 and memory[ids.selected_encodings] == memory[ids.all_encodings]) +if ids.select_builtin: + n_selected_builtins = n_selected_builtins - 1"; diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs new file mode 100644 index 0000000..a9458c4 --- /dev/null +++ b/src/hints/execute_task_hints.rs @@ -0,0 +1,883 @@ +use std::any::Any; +use std::collections::HashMap; + +use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{ + get_ptr_from_var_name, get_relocatable_from_var_name, insert_value_from_var_name, +}; +use cairo_vm::hint_processor::hint_processor_definition::HintReference; +use cairo_vm::serde::deserialize_program::{ApTracking, Identifier}; +use cairo_vm::types::builtin_name::BuiltinName; +use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::types::relocatable::Relocatable; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::errors::memory_errors::MemoryError; +use cairo_vm::vm::runners::builtin_runner::{OutputBuiltinRunner, OutputBuiltinState}; +use cairo_vm::vm::runners::cairo_pie::{CairoPie, OutputBuiltinAdditionalData, StrippedProgram}; +use cairo_vm::vm::vm_core::VirtualMachine; +use cairo_vm::{any_box, Felt252}; +use starknet_crypto::FieldElement; + +use crate::hints::fact_topologies::{get_task_fact_topology, FactTopology}; +use crate::hints::load_cairo_pie::load_cairo_pie; +use crate::hints::program_hash::compute_program_hash_chain; +use crate::hints::program_loader::ProgramLoader; +use crate::hints::types::{BootloaderVersion, ProgramIdentifiers, Task}; +use crate::hints::vars; + +fn get_program_from_task(task: &Task) -> Result { + task.get_program() + .map_err(|e| HintError::CustomHint(e.to_string().into_boxed_str())) +} + +/// Implements %{ ids.program_data_ptr = program_data_base = segments.add() %}. +/// +/// Creates a new segment to store the program data. +pub fn allocate_program_data_segment( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let program_data_segment = vm.add_memory_segment(); + exec_scopes.insert_value(vars::PROGRAM_DATA_BASE, program_data_segment); + insert_value_from_var_name( + "program_data_ptr", + program_data_segment, + vm, + ids_data, + ap_tracking, + )?; + + Ok(()) +} + +fn field_element_to_felt(field_element: FieldElement) -> Felt252 { + let bytes = field_element.to_bytes_be(); + Felt252::from_bytes_be(&bytes) +} + +/// Implements +/// +/// from starkware.cairo.bootloaders.simple_bootloader.utils import load_program +/// +/// # Call load_program to load the program header and code to memory. +/// program_address, program_data_size = load_program( +/// task=task, memory=memory, program_header=ids.program_header, +/// builtins_offset=ids.ProgramHeader.builtin_list) +/// segments.finalize(program_data_base.segment_index, program_data_size) +pub fn load_program_hint( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let program_data_base: Relocatable = exec_scopes.get(vars::PROGRAM_DATA_BASE)?; + let task: Task = exec_scopes.get(vars::TASK)?; + let program = get_program_from_task(&task)?; + + let program_header_ptr = get_ptr_from_var_name("program_header", vm, ids_data, ap_tracking)?; + + // Offset of the builtin_list field in `ProgramHeader`, cf. execute_task.cairo + let builtins_offset = 4; + let mut program_loader = ProgramLoader::new(vm, builtins_offset); + let bootloader_version: BootloaderVersion = 0; + let loaded_program = program_loader + .load_program(program_header_ptr, &program, Some(bootloader_version)) + .map_err(Into::::into)?; + + vm.segments.finalize( + Some(loaded_program.size), + program_data_base.segment_index as usize, + None, + ); + + exec_scopes.insert_value(vars::PROGRAM_ADDRESS, loaded_program.code_address); + + Ok(()) +} + +/// Implements +/// from starkware.cairo.bootloaders.simple_bootloader.utils import get_task_fact_topology +/// +/// # Add the fact topology of the current task to 'fact_topologies'. +/// output_start = ids.pre_execution_builtin_ptrs.output +/// output_end = ids.return_builtin_ptrs.output +/// fact_topologies.append(get_task_fact_topology( +/// output_size=output_end - output_start, +/// task=task, +/// output_builtin=output_builtin, +/// output_runner_data=output_runner_data, +/// )) +pub fn append_fact_topologies( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let task: Task = exec_scopes.get(vars::TASK)?; + let output_runner_data: Option = + exec_scopes.get(vars::OUTPUT_RUNNER_DATA)?; + let fact_topologies: &mut Vec = exec_scopes.get_mut_ref(vars::FACT_TOPOLOGIES)?; + + let pre_execution_builtin_ptrs_addr = + get_relocatable_from_var_name("pre_execution_builtin_ptrs", vm, ids_data, ap_tracking)?; + let return_builtin_ptrs_addr = + get_relocatable_from_var_name("return_builtin_ptrs", vm, ids_data, ap_tracking)?; + + // The output field is the first one in the BuiltinData struct + let output_start = vm.get_relocatable(pre_execution_builtin_ptrs_addr)?; + let output_end = vm.get_relocatable(return_builtin_ptrs_addr)?; + let output_size = (output_end - output_start)?; + + let output_builtin = vm.get_output_builtin_mut()?; + let fact_topology = + get_task_fact_topology(output_size, &task, output_builtin, output_runner_data) + .map_err(Into::::into)?; + fact_topologies.push(fact_topology); + + Ok(()) +} + +/// Implements +/// # Validate hash. +/// from starkware.cairo.bootloaders.hash_program import compute_program_hash_chain +/// +/// assert memory[ids.output_ptr + 1] == compute_program_hash_chain(task.get_program()), \ +/// 'Computed hash does not match input.'"; +pub fn validate_hash( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let task: Task = exec_scopes.get(vars::TASK)?; + let program = get_program_from_task(&task)?; + + let output_ptr = get_ptr_from_var_name("output_ptr", vm, ids_data, ap_tracking)?; + let program_hash_ptr = (output_ptr + 1)?; + + let program_hash = vm.get_integer(program_hash_ptr)?.into_owned(); + + // Compute the hash of the program + let computed_program_hash = compute_program_hash_chain(&program, 0).map_err(|e| { + HintError::CustomHint(format!("Could not compute program hash: {e}").into_boxed_str()) + })?; + let computed_program_hash = field_element_to_felt(computed_program_hash); + + if program_hash != computed_program_hash { + return Err(HintError::AssertionFailed( + "Computed hash does not match input" + .to_string() + .into_boxed_str(), + )); + } + + Ok(()) +} + +/// List of all builtins in the order used by the bootloader. +const ALL_BUILTINS: [BuiltinName; 8] = [ + BuiltinName::output, + BuiltinName::pedersen, + BuiltinName::range_check, + BuiltinName::ecdsa, + BuiltinName::bitwise, + BuiltinName::ec_op, + BuiltinName::keccak, + BuiltinName::poseidon, +]; + +fn check_cairo_pie_builtin_usage( + vm: &mut VirtualMachine, + builtin_name: &BuiltinName, + builtin_index: usize, + cairo_pie: &CairoPie, + return_builtins_addr: Relocatable, + pre_execution_builtins_addr: Relocatable, +) -> Result<(), HintError> { + let return_builtin_value = vm.get_relocatable((return_builtins_addr + builtin_index)?)?; + let pre_execution_builtin_value = + vm.get_relocatable((pre_execution_builtins_addr + builtin_index)?)?; + let expected_builtin_size = (return_builtin_value - pre_execution_builtin_value)?; + + let builtin_size = cairo_pie.metadata.builtin_segments[builtin_name].size; + + if builtin_size != expected_builtin_size { + return Err(HintError::AssertionFailed( + "Builtin usage is inconsistent with the CairoPie." + .to_string() + .into_boxed_str(), + )); + } + + Ok(()) +} + +/// Writes the updated builtin pointers after the program execution to the given return builtins +/// address. +/// +/// `used_builtins` is the list of builtins used by the program and thus updated by it. +fn write_return_builtins( + vm: &mut VirtualMachine, + return_builtins_addr: Relocatable, + used_builtins: &[BuiltinName], + used_builtins_addr: Relocatable, + pre_execution_builtins_addr: Relocatable, + task: &Task, +) -> Result<(), HintError> { + let mut used_builtin_offset: usize = 0; + for (index, builtin) in ALL_BUILTINS.iter().enumerate() { + if used_builtins.contains(builtin) { + let builtin_value = vm.get_relocatable((used_builtins_addr + used_builtin_offset)?)?; + vm.insert_value((return_builtins_addr + index)?, builtin_value)?; + used_builtin_offset += 1; + + if let Task::Pie(cairo_pie) = task { + check_cairo_pie_builtin_usage( + vm, + builtin, + index, + cairo_pie, + return_builtins_addr, + pre_execution_builtins_addr, + )?; + } + } + // The builtin is unused, hence its value is the same as before calling the program. + else { + let pre_execution_builtin_addr = (pre_execution_builtins_addr + index)?; + let pre_execution_value = + vm.get_maybe(&pre_execution_builtin_addr).ok_or_else(|| { + MemoryError::UnknownMemoryCell(Box::new(pre_execution_builtin_addr)) + })?; + vm.insert_value((return_builtins_addr + index)?, pre_execution_value)?; + } + } + Ok(()) +} + +/// Implements +/// from starkware.cairo.bootloaders.simple_bootloader.utils import write_return_builtins +/// +/// # Fill the values of all builtin pointers after executing the task. +/// builtins = task.get_program().builtins +/// write_return_builtins( +/// memory=memory, return_builtins_addr=ids.return_builtin_ptrs.address_, +/// used_builtins=builtins, used_builtins_addr=ids.used_builtins_addr, +/// pre_execution_builtins_addr=ids.pre_execution_builtin_ptrs.address_, task=task) +/// +/// vm_enter_scope({'n_selected_builtins': n_builtins}) +/// +/// This hint looks at the builtins written by the program and merges them with the stored +/// pre-execution values (stored in a struct named ids.pre_execution_builtin_ptrs) to +/// create a final BuiltinData struct for the program. +pub fn write_return_builtins_hint( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let task: Task = exec_scopes.get(vars::TASK)?; + let n_builtins: usize = exec_scopes.get(vars::N_BUILTINS)?; + + // builtins = task.get_program().builtins + let program = get_program_from_task(&task)?; + let builtins = &program.builtins; + + // write_return_builtins( + // memory=memory, return_builtins_addr=ids.return_builtin_ptrs.address_, + // used_builtins=builtins, used_builtins_addr=ids.used_builtins_addr, + // pre_execution_builtins_addr=ids.pre_execution_builtin_ptrs.address_, task=task) + let return_builtins_addr = + get_relocatable_from_var_name("return_builtin_ptrs", vm, ids_data, ap_tracking)?; + let used_builtins_addr = + get_ptr_from_var_name("used_builtins_addr", vm, ids_data, ap_tracking)?; + let pre_execution_builtins_addr = + get_relocatable_from_var_name("pre_execution_builtin_ptrs", vm, ids_data, ap_tracking)?; + + write_return_builtins( + vm, + return_builtins_addr, + builtins, + used_builtins_addr, + pre_execution_builtins_addr, + &task, + )?; + + // vm_enter_scope({'n_selected_builtins': n_builtins}) + let n_builtins: Box = Box::new(n_builtins); + exec_scopes.enter_scope(HashMap::from([( + vars::N_SELECTED_BUILTINS.to_string(), + n_builtins, + )])); + + Ok(()) +} + +fn get_bootloader_program(exec_scopes: &ExecutionScopes) -> Result<&ProgramIdentifiers, HintError> { + if let Some(boxed_program) = exec_scopes.data[0].get(vars::BOOTLOADER_PROGRAM_IDENTIFIERS) { + if let Some(program) = boxed_program.downcast_ref::() { + return Ok(program); + } + } + + Err(HintError::VariableNotInScopeError( + vars::BOOTLOADER_PROGRAM_IDENTIFIERS + .to_string() + .into_boxed_str(), + )) +} + +fn get_identifier( + identifiers: &HashMap, + name: &str, +) -> Result { + if let Some(identifier) = identifiers.get(name) { + if let Some(pc) = identifier.pc { + return Ok(pc); + } + } + + Err(HintError::VariableNotInScopeError( + name.to_string().into_boxed_str(), + )) +} + +/* +Implements hint: +%{ + "from starkware.cairo.bootloaders.simple_bootloader.objects import ( + CairoPieTask, + RunProgramTask, + Task, + ) + from starkware.cairo.bootloaders.simple_bootloader.utils import ( + load_cairo_pie, + prepare_output_runner, + ) + + assert isinstance(task, Task) + n_builtins = len(task.get_program().builtins) + new_task_locals = {} + if isinstance(task, RunProgramTask): + new_task_locals['program_input'] = task.program_input + new_task_locals['WITH_BOOTLOADER'] = True + + vm_load_program(task.program, program_address) + elif isinstance(task, CairoPieTask): + ret_pc = ids.ret_pc_label.instruction_offset_ - ids.call_task.instruction_offset_ + pc + load_cairo_pie( + task=task.cairo_pie, memory=memory, segments=segments, + program_address=program_address, execution_segment_address= ap - n_builtins, + builtin_runners=builtin_runners, ret_fp=fp, ret_pc=ret_pc) + else: + raise NotImplementedError(f'Unexpected task type: {type(task).__name__}.') + + output_runner_data = prepare_output_runner( + task=task, + output_builtin=output_builtin, + output_ptr=ids.pre_execution_builtin_ptrs.output) + vm_enter_scope(new_task_locals)" +%} +*/ +pub fn call_task( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + // assert isinstance(task, Task) + let task: Task = exec_scopes.get(vars::TASK)?; + + // n_builtins = len(task.get_program().builtins) + let n_builtins = get_program_from_task(&task)?.builtins.len(); + exec_scopes.insert_value(vars::N_BUILTINS, n_builtins); + + let mut new_task_locals = HashMap::new(); + + match &task { + // if isinstance(task, RunProgramTask): + Task::Program(_program) => { + let program_input = HashMap::>::new(); + // new_task_locals['program_input'] = task.program_input + new_task_locals.insert("program_input".to_string(), any_box![program_input]); + // new_task_locals['WITH_BOOTLOADER'] = True + new_task_locals.insert("WITH_BOOTLOADER".to_string(), any_box![true]); + + // TODO: the content of this function is mostly useless for the Rust VM. + // check with SW if there is nothing of interest here. + // vm_load_program(task.program, program_address) + } + // elif isinstance(task, CairoPieTask): + Task::Pie(cairo_pie) => { + let program_address: Relocatable = exec_scopes.get("program_address")?; + + // ret_pc = ids.ret_pc_label.instruction_offset_ - ids.call_task.instruction_offset_ + pc + let bootloader_identifiers = get_bootloader_program(exec_scopes)?; + let ret_pc_label = get_identifier(bootloader_identifiers, "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ret_pc_label")?; + let call_task = get_identifier( + bootloader_identifiers, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.call_task", + )?; + + let ret_pc_offset = ret_pc_label - call_task; + let ret_pc = (vm.get_pc() + ret_pc_offset)?; + + // load_cairo_pie( + // task=task.cairo_pie, memory=memory, segments=segments, + // program_address=program_address, execution_segment_address= ap - n_builtins, + // builtin_runners=builtin_runners, ret_fp=fp, ret_pc=ret_pc) + load_cairo_pie( + cairo_pie, + vm, + program_address, + (vm.get_ap() - n_builtins)?, + vm.get_fp(), + ret_pc, + ) + .map_err(Into::::into)?; + } + } + + // output_runner_data = prepare_output_runner( + // task=task, + // output_builtin=output_builtin, + // output_ptr=ids.pre_execution_builtin_ptrs.output) + let pre_execution_builtin_ptrs_addr = + get_relocatable_from_var_name(vars::PRE_EXECUTION_BUILTIN_PTRS, vm, ids_data, ap_tracking)?; + // The output field is the first one in the BuiltinData struct + let output_ptr = vm.get_relocatable((pre_execution_builtin_ptrs_addr + 0)?)?; + let output_runner_data = + util::prepare_output_runner(&task, vm.get_output_builtin_mut()?, output_ptr)?; + + exec_scopes.insert_value(vars::OUTPUT_RUNNER_DATA, output_runner_data); + + exec_scopes.enter_scope(new_task_locals); + + Ok(()) +} + +mod util { + use cairo_vm::vm::runners::cairo_pie::BuiltinAdditionalData; + + // TODO: clean up / organize + use super::*; + + /// Prepares the output builtin if the type of task is Task, so that pages of the inner program + /// will be recorded separately. + /// If the type of task is CairoPie, nothing should be done, as the program does not contain + /// hints that may affect the output builtin. + /// The return value of this function should be later passed to get_task_fact_topology(). + pub(crate) fn prepare_output_runner( + task: &Task, + output_builtin: &mut OutputBuiltinRunner, + output_ptr: Relocatable, + ) -> Result, HintError> { + match task { + Task::Program(_) => { + let output_state = match output_builtin.get_additional_data() { + BuiltinAdditionalData::Output(output_state) => Ok(output_state), + _ => Err(HintError::CustomHint( + "output_builtin's additional data is not type Output" + .to_string() + .into_boxed_str(), + )), + }?; + output_builtin.new_state(output_ptr.segment_index as usize, true); + Ok(Some(output_state)) + } + Task::Pie(_) => Ok(None), + } + } +} + +#[cfg(test)] +mod tests { + use std::path::Path; + use std::sync::Arc; + + use assert_matches::assert_matches; + use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::{ + BuiltinHintProcessor, HintProcessorData, + }; + use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_maybe_relocatable_from_var_name; + use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; + use cairo_vm::serde::deserialize_program::OffsetValue; + use cairo_vm::vm::runners::builtin_runner::BuiltinRunner; + use cairo_vm::vm::runners::cairo_pie::PublicMemoryPage; + use cairo_vm::{any_box, relocatable, Felt252}; + use num_traits::ToPrimitive; + use rstest::{fixture, rstest}; + + use crate::hints::types::{BootloaderConfig, SimpleBootloaderInput}; + + use super::*; + + #[rstest] + fn test_allocate_program_data_segment() { + let mut vm = vm!(); + // Allocate space for program_data_ptr + vm.run_context.fp = 1; + add_segments!(vm, 2); + let ids_data = ids_data!["program_data_ptr"]; + let expected_program_data_segment_index = vm.segments.num_segments(); + + let mut exec_scopes = ExecutionScopes::new(); + let ap_tracking = ApTracking::new(); + + allocate_program_data_segment(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Hint failed unexpectedly"); + + let program_data_ptr = + get_ptr_from_var_name("program_data_ptr", &mut vm, &ids_data, &ap_tracking) + .expect("program_data_ptr is not set"); + + let program_data_base: Relocatable = exec_scopes + .get(vars::PROGRAM_DATA_BASE) + .expect(format!("{} is not set", vars::PROGRAM_DATA_BASE).as_ref()); + + assert_eq!(program_data_ptr, program_data_base); + // Check that we allocated a new segment and that the pointers point to it + assert_eq!( + vm.segments.num_segments(), + expected_program_data_segment_index + 1 + ); + assert_eq!( + program_data_ptr, + Relocatable { + segment_index: expected_program_data_segment_index as isize, + offset: 0 + } + ); + } + + #[fixture] + fn fibonacci() -> Program { + let program_content = + include_bytes!("../../../../../cairo_programs/fibonacci.json").to_vec(); + + Program::from_bytes(&program_content, Some("main")) + .expect("Loading example program failed unexpectedly") + } + + #[fixture] + fn fibonacci_pie() -> CairoPie { + let pie_file = + Path::new("../cairo_programs/manually_compiled/fibonacci_cairo_pie/fibonacci_pie.zip"); + CairoPie::from_file(pie_file).expect("Failed to load the program PIE") + } + + #[fixture] + fn field_arithmetic_program() -> Program { + let program_content = + include_bytes!("../../../../../cairo_programs/field_arithmetic.json").to_vec(); + + Program::from_bytes(&program_content, Some("main")) + .expect("Loading example program failed unexpectedly") + } + + #[rstest] + fn test_load_program(fibonacci: Program) { + let task = Task::Program(fibonacci.clone()); + + let mut vm = vm!(); + vm.run_context.fp = 1; + // Set program_header_ptr to (2, 0) + vm.segments = segments![((1, 0), (2, 0))]; + let program_header_ptr = Relocatable::from((2, 0)); + add_segments!(vm, 1); + + let mut exec_scopes = ExecutionScopes::new(); + exec_scopes.insert_value(vars::PROGRAM_DATA_BASE, program_header_ptr.clone()); + exec_scopes.insert_value(vars::TASK, task); + + let ids_data = ids_data!["program_header"]; + let ap_tracking = ApTracking::new(); + + load_program_hint(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Hint failed unexpectedly"); + + // Note that we do not check the loaded content in memory here, this is tested + // in `program_loader.rs` + + // The Fibonacci program has no builtins -> the header size is 4 + let header_size = 4; + let expected_code_address = &program_header_ptr + header_size; + + let program_address: Relocatable = exec_scopes.get(vars::PROGRAM_ADDRESS).unwrap(); + assert_eq!(program_address, expected_code_address); + + // Check that the segment was finalized + let expected_program_size = header_size + fibonacci.shared_program_data.data.len(); + assert_eq!( + vm.segments.segment_sizes[&(program_address.segment_index as usize)], + expected_program_size + ); + } + + #[rstest] + fn test_call_task(fibonacci: Program) { + let mut vm = vm!(); + + // Allocate space for pre-execution (8 felts), which mimics the `BuiltinData` struct in the + // Bootloader's Cairo code. Our code only uses the first felt (`output` field in the struct) + vm.segments = segments![((1, 0), (2, 0))]; + vm.run_context.fp = 8; + add_segments!(vm, 1); + + let ids_data = non_continuous_ids_data![(vars::PRE_EXECUTION_BUILTIN_PTRS, -8)]; + + let mut exec_scopes = ExecutionScopes::new(); + + let mut output_builtin = OutputBuiltinRunner::new(true); + output_builtin.initialize_segments(&mut vm.segments); + vm.builtin_runners + .push(BuiltinRunner::Output(output_builtin)); + + let task = Task::Program(fibonacci); + exec_scopes.insert_box(vars::TASK, Box::new(task)); + + assert_matches!( + run_hint!( + vm, + ids_data.clone(), + hint_code::EXECUTE_TASK_CALL_TASK, + &mut exec_scopes + ), + Ok(()) + ); + } + + /// Creates a fake Program struct to act as a placeholder for the `BOOTLOADER_PROGRAM` variable. + /// These other options have been considered: + /// * a `HasIdentifiers` trait cannot be used as exec_scopes requires to cast to `Box`, + /// making casting back to the trait impossible. + /// * using an enum requires defining test-only variants. + fn mock_program_with_identifiers(symbols: HashMap) -> Program { + let identifiers = symbols + .into_iter() + .map(|(name, pc)| { + ( + name, + Identifier { + pc: Some(pc), + type_: None, + value: None, + full_name: None, + members: None, + cairo_type: None, + }, + ) + }) + .collect(); + + let shared_program_data = SharedProgramData { + identifiers, + ..Default::default() + }; + let program = Program { + shared_program_data: Arc::new(shared_program_data), + constants: Default::default(), + builtins: vec![], + }; + + program + } + + #[rstest] + fn test_call_cairo_pie_task(fibonacci_pie: CairoPie) { + let mut vm = vm!(); + + // We set the program header pointer at (1, 0) and make it point to the start of segment #2. + // Allocate space for pre-execution (8 values), which follows the `BuiltinData` struct in + // the Bootloader Cairo code. Our code only uses the first felt (`output` field in the + // struct). Finally, we put the mocked output of `select_input_builtins` in the next + // memory address and increase the AP register accordingly. + vm.segments = segments![((1, 0), (2, 0)), ((1, 1), (4, 0)), ((1, 9), (4, 42))]; + vm.run_context.ap = 10; + vm.run_context.fp = 9; + add_segments!(vm, 3); + + let program_header_ptr = Relocatable::from((2, 0)); + let ids_data = non_continuous_ids_data![ + ("program_header", -9), + (vars::PRE_EXECUTION_BUILTIN_PTRS, -8), + ]; + let ap_tracking = ApTracking::new(); + + let mut exec_scopes = ExecutionScopes::new(); + + let mut output_builtin = OutputBuiltinRunner::new(true); + output_builtin.initialize_segments(&mut vm.segments); + vm.builtin_runners + .push(BuiltinRunner::Output(output_builtin)); + + let task = Task::Pie(fibonacci_pie); + exec_scopes.insert_value(vars::TASK, task); + let bootloader_identifiers = HashMap::from( + [ + ("starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ret_pc_label".to_string(), 10usize), + ("starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.call_task".to_string(), 8usize) + ] + ); + let bootloader_program = mock_program_with_identifiers(bootloader_identifiers); + exec_scopes.insert_value(vars::PROGRAM_DATA_BASE, program_header_ptr.clone()); + exec_scopes.insert_value(vars::BOOTLOADER_PROGRAM_IDENTIFIERS, bootloader_program); + + // Load the program in memory + load_program_hint(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Failed to load Cairo PIE task in the VM memory"); + + // Execute it + call_task(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Hint failed unexpectedly"); + } + + #[rstest] + fn test_append_fact_topologies(fibonacci: Program) { + let task = Task::Program(fibonacci.clone()); + + let mut vm = vm!(); + + // Allocate space for the pre-execution and return builtin structs (2 x 8 felts). + // The pre-execution struct starts at (1, 0) and the return struct at (1, 8). + // We only set the output values to (2, 0) and (2, 10), respectively, to get an output size + // of 10. + vm.segments = segments![((1, 0), (2, 0)), ((1, 8), (2, 10)),]; + vm.run_context.fp = 16; + add_segments!(vm, 1); + + let tree_structure = vec![1, 2, 3, 4]; + let program_output_data = OutputBuiltinAdditionalData { + base: 0, + pages: HashMap::from([ + (1, PublicMemoryPage { start: 0, size: 7 }), + (2, PublicMemoryPage { start: 7, size: 3 }), + ]), + attributes: HashMap::from([("gps_fact_topology".to_string(), tree_structure.clone())]), + }; + let mut output_builtin = OutputBuiltinRunner::new(true); + output_builtin.set_state(program_output_data.clone()); + output_builtin.initialize_segments(&mut vm.segments); + vm.builtin_runners + .push(BuiltinRunner::Output(output_builtin)); + + let ids_data = non_continuous_ids_data![ + ("pre_execution_builtin_ptrs", -16), + ("return_builtin_ptrs", -8), + ]; + + let ap_tracking = ApTracking::new(); + + let mut exec_scopes = ExecutionScopes::new(); + + let output_runner_data = OutputBuiltinAdditionalData { + base: 0, + pages: HashMap::new(), + attributes: HashMap::new(), + }; + exec_scopes.insert_value(vars::OUTPUT_RUNNER_DATA, Some(output_runner_data.clone())); + exec_scopes.insert_value(vars::TASK, task); + exec_scopes.insert_value(vars::FACT_TOPOLOGIES, Vec::::new()); + + append_fact_topologies(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Hint failed unexpectedly"); + + // Check that the fact topology matches the data from the output builtin + let fact_topologies: Vec = exec_scopes.get(vars::FACT_TOPOLOGIES).unwrap(); + assert_eq!(fact_topologies.len(), 1); + + let fact_topology = &fact_topologies[0]; + assert_eq!(fact_topology.page_sizes, vec![0, 7, 3]); + assert_eq!(fact_topology.tree_structure, tree_structure); + + // Check that the output builtin was updated + let output_builtin_additional_data = vm.get_output_builtin().unwrap().get_additional_data(); + assert!(matches!( + output_builtin_additional_data, + BuiltinAdditionalData::Output(data) if data == output_runner_data, + )); + } + + #[rstest] + fn test_write_output_builtins(field_arithmetic_program: Program) { + let task = Task::Program(field_arithmetic_program.clone()); + + let mut vm = vm!(); + // Allocate space for all the builtin list structs (3 x 8 felts). + // The pre-execution struct starts at (1, 0), the used builtins list at (1, 8) + // and the return struct at (1, 16). + // Initialize the pre-execution struct to [1, 2, 3, 4, 5, 6, 7, 8]. + // Initialize the used builtins to {range_check: 30, bitwise: 50} as these two + // are used by the field arithmetic program. Note that the used builtins list + // does not contain empty elements (i.e. offsets are 8 and 9 instead of 10 and 12). + vm.segments = segments![ + ((1, 0), (2, 1)), + ((1, 1), (2, 2)), + ((1, 2), (2, 3)), + ((1, 3), (2, 4)), + ((1, 4), (2, 5)), + ((1, 5), (2, 6)), + ((1, 6), (2, 7)), + ((1, 7), (2, 8)), + ((1, 8), (2, 30)), + ((1, 9), (2, 50)), + ((1, 24), (1, 8)), + ]; + vm.run_context.fp = 25; + add_segments!(vm, 1); + + // Note that used_builtins_addr is a pointer to the used builtins list at (1, 8) + let ids_data = non_continuous_ids_data![ + ("pre_execution_builtin_ptrs", -25), + ("return_builtin_ptrs", -9), + ("used_builtins_addr", -1), + ]; + let ap_tracking = ApTracking::new(); + + let mut exec_scopes = ExecutionScopes::new(); + let n_builtins = field_arithmetic_program.builtins.len(); + exec_scopes.insert_value(vars::N_BUILTINS, n_builtins); + exec_scopes.insert_value(vars::TASK, task); + + write_return_builtins_hint(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Hint failed unexpectedly"); + + // Check that the return builtins were written correctly + let return_builtins = vm + .segments + .memory + .get_continuous_range(Relocatable::from((1, 16)), 8) + .expect("Return builtin was not properly written to memory."); + + let expected_builtins = vec![ + Relocatable::from((2, 1)), + Relocatable::from((2, 2)), + Relocatable::from((2, 30)), + Relocatable::from((2, 4)), + Relocatable::from((2, 50)), + Relocatable::from((2, 6)), + Relocatable::from((2, 7)), + Relocatable::from((2, 8)), + ]; + for (expected, actual) in std::iter::zip(expected_builtins, return_builtins) { + assert_eq!(MaybeRelocatable::RelocatableValue(expected), actual); + } + + // Check that the exec scope changed + assert_eq!( + exec_scopes.data.len(), + 2, + "A new scope should have been declared" + ); + assert_eq!( + exec_scopes.data[1].len(), + 1, + "The new scope should only contain one variable" + ); + let n_selected_builtins: usize = exec_scopes + .get(vars::N_SELECTED_BUILTINS) + .expect("n_selected_builtins should be set"); + assert_eq!(n_selected_builtins, n_builtins); + } +} diff --git a/src/hints/fact_topologies.rs b/src/hints/fact_topologies.rs new file mode 100644 index 0000000..d3b851a --- /dev/null +++ b/src/hints/fact_topologies.rs @@ -0,0 +1,689 @@ +use cairo_vm::types::builtin_name::BuiltinName; +use std::fs::File; +use std::path::Path; + +use cairo_vm::types::errors::math_errors::MathError; +use cairo_vm::types::relocatable::Relocatable; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::errors::runner_errors::RunnerError; +use cairo_vm::vm::runners::builtin_runner::{OutputBuiltinRunner, OutputBuiltinState}; +use cairo_vm::vm::runners::cairo_pie::{ + BuiltinAdditionalData, OutputBuiltinAdditionalData, Pages, PublicMemoryPage, +}; +use serde::Serialize; + +use crate::hints::types::{PackedOutput, Task}; + +#[derive(Clone, Debug, PartialEq, Serialize)] +pub struct FactTopology { + #[allow(dead_code)] + pub tree_structure: Vec, + pub page_sizes: Vec, +} + +#[derive(Serialize)] +struct FactTopologyFile<'a> { + fact_topologies: Vec<&'a FactTopology>, +} + +impl AsRef for FactTopology { + fn as_ref(&self) -> &FactTopology { + self + } +} + +#[derive(thiserror_no_std::Error, Debug)] +pub enum PageError { + #[error("Expected page ID {0}, found {1}")] + UnexpectedPageId(usize, usize), + + #[error("Invalid page start: {0}")] + InvalidPageStart(usize), + + #[error("Expected page start {0}, found {1}")] + UnexpectedPageStart(usize, usize), + + #[error("Pages must cover the entire program output")] + OutputNotFullyCovered, +} + +#[derive(thiserror_no_std::Error, Debug)] +pub enum TreeStructureError { + #[error("Invalid tree structure specified in the gps_fact_topology attribute")] + InvalidTreeStructure, + + #[error( + "Additional pages cannot be used since the gps_fact_topology attribute is not specified" + )] + CannotUseAdditionalPages, +} + +#[derive(Debug, thiserror_no_std::Error)] +pub enum FactTopologyError { + #[error(transparent)] + Math(#[from] MathError), + + #[error(transparent)] + PageSize(#[from] PageError), + + #[error(transparent)] + TreeStructure(#[from] TreeStructureError), + + #[error("Expected {0} fact topologies but got {1}")] + WrongNumberOfFactTopologies(usize, usize), + + #[error("Composite packed outputs are not supported yet")] + CompositePackedOutputNotSupported(PackedOutput), + + #[error("Could not add page to output: {0}")] + FailedToAddOutputPage(#[from] RunnerError), + + #[error("Could not load output builtin additional data from Cairo PIE")] + CairoPieHasNoOutputBuiltinData, + + #[error("Unexpected error: {0}")] + Internal(Box), +} + +impl From for HintError { + fn from(value: FactTopologyError) -> Self { + match value { + FactTopologyError::Math(e) => HintError::Math(e), + FactTopologyError::WrongNumberOfFactTopologies(_, _) => { + HintError::AssertionFailed(value.to_string().into_boxed_str()) + } + _ => HintError::CustomHint(value.to_string().into_boxed_str()), + } + } +} + +#[derive(thiserror_no_std::Error, Debug)] +pub enum WriteFactTopologiesError { + #[error("Failed to create fact topology file: {0}")] + Io(#[from] std::io::Error), + #[error("Failed to serialize fact topologies: {0}")] + Serialization(#[from] serde_json::Error), +} + +impl From for HintError { + fn from(value: WriteFactTopologiesError) -> Self { + HintError::CustomHint(value.to_string().into_boxed_str()) + } +} + +/// Flattens and extracts the fact topologies from packed outputs. +/// +/// Note that `packed_outputs` and `fact_topologies` must have the same length. +/// +/// * `packed_outputs`: Packed outputs. +/// * `fact_topologies`: Fact topologies. +pub fn compute_fact_topologies<'a>( + packed_outputs: &Vec, + fact_topologies: &'a Vec, +) -> Result, FactTopologyError> { + if packed_outputs.len() != fact_topologies.len() { + return Err(FactTopologyError::WrongNumberOfFactTopologies( + packed_outputs.len(), + fact_topologies.len(), + )); + } + + let mut plain_fact_topologies = vec![]; + + for (packed_output, fact_topology) in std::iter::zip(packed_outputs, fact_topologies) { + match packed_output { + PackedOutput::Plain(_) => { + plain_fact_topologies.push(fact_topology); + } + PackedOutput::Composite(_) => { + return Err(FactTopologyError::CompositePackedOutputNotSupported( + packed_output.clone(), + )); + } + } + } + + Ok(plain_fact_topologies) +} + +/// Adds page to the output builtin for the specified fact topology. +/// +/// * `fact_topology`: Fact topology. +/// * `output_builtin`: Output builtin of the VM. +/// * `current_page_id`: First page ID to use. +/// * `output_start`: Start of the output range for this fact topology. +/// +/// Reimplements the following Python code: +/// offset = 0 +/// for i, page_size in enumerate(fact_topology.page_sizes): +/// output_builtin.add_page( +/// page_id=cur_page_id + i, page_start=output_start + offset, page_size=page_size +/// ) +/// offset += page_size +/// +/// return len(fact_topology.page_sizes) +fn add_consecutive_output_pages( + fact_topology: &FactTopology, + output_builtin: &mut OutputBuiltinRunner, + current_page_id: usize, + output_start: Relocatable, +) -> Result { + let mut offset = 0; + + for (i, page_size) in fact_topology.page_sizes.iter().copied().enumerate() { + let page_id = current_page_id + i; + let page_start = (output_start + offset)?; + output_builtin.add_page(page_id, page_start, page_size)?; + offset += page_size; + } + + Ok(fact_topology.page_sizes.len()) +} + +/// Given the fact_topologies of the tasks that were run by bootloader, configure the +/// corresponding pages in the output builtin. +/// +/// Assumes that the bootloader output 2 words per task. +/// +/// * `plain_fact_topologies`: Fact topologies. +/// * `output_start`: Start of the bootloader output. +/// * `output_builtin`: Output builtin of the VM. +/// +/// Reimplements the following Python code: +/// cur_page_id = 1 +/// for fact_topology in fact_topologies: +/// # Skip bootloader output for each task. +/// output_start += 2 +/// cur_page_id += add_consecutive_output_pages( +/// fact_topology=fact_topology, +/// output_builtin=output_builtin, +/// cur_page_id=cur_page_id, +/// output_start=output_start, +/// ) +/// output_start += sum(fact_topology.page_sizes) + +pub fn configure_fact_topologies>( + plain_fact_topologies: &[FT], + output_start: &mut Relocatable, + output_builtin: &mut OutputBuiltinRunner, +) -> Result<(), FactTopologyError> { + // Each task may use a few memory pages. Start from page 1 (as page 0 is reserved for the + // bootloader program and arguments). + let mut current_page_id: usize = 1; + for fact_topology in plain_fact_topologies { + // Skip bootloader output for each task + *output_start = (*output_start + 2usize)?; + + current_page_id += add_consecutive_output_pages( + fact_topology.as_ref(), + output_builtin, + current_page_id, + *output_start, + )?; + let total_page_sizes: usize = fact_topology.as_ref().page_sizes.iter().sum(); + *output_start = (*output_start + total_page_sizes)?; + } + + Ok(()) +} + +fn check_tree_structure(tree_structure: &[usize]) -> Result<(), TreeStructureError> { + if (!tree_structure.len().is_power_of_two()) || (tree_structure.len() > 10) { + return Err(TreeStructureError::InvalidTreeStructure); + } + + let max_element_size: usize = 1 << 30; + for x in tree_structure { + if *x > max_element_size { + return Err(TreeStructureError::InvalidTreeStructure); + } + } + + Ok(()) +} + +const GPS_FACT_TOPOLOGY: &str = "gps_fact_topology"; + +/// Extracts the tree structure from the output data attributes, or returns a default. +fn get_tree_structure_from_output_data( + output_builtin_additional_data: &OutputBuiltinAdditionalData, +) -> Result, TreeStructureError> { + let pages = &output_builtin_additional_data.pages; + let attributes = &output_builtin_additional_data.attributes; + + // If the GPS_FACT_TOPOLOGY attribute is present, use it. Otherwise, the task is expected to + // use exactly one page (page 0). + let tree_structure = match attributes.get(GPS_FACT_TOPOLOGY) { + Some(tree_structure_attr) => { + check_tree_structure(tree_structure_attr)?; + tree_structure_attr.clone() + } + None => { + if !pages.is_empty() { + return Err(TreeStructureError::CannotUseAdditionalPages); + } + vec![1, 0] + } + }; + + Ok(tree_structure) +} + +/// Returns the sizes of the program output pages, given the pages that appears +/// in the additional attributes of the output builtin. +fn get_page_sizes_from_pages(output_size: usize, pages: &Pages) -> Result, PageError> { + // Make sure the pages are adjacent to each other. + + // The first page id is expected to be 1. + let mut expected_page_id: usize = 1; + // We don't expect anything on its start value. + let mut expected_page_start: usize = 0; + // The size of page 0 is output_size if there are no other pages, or the start of page 1 + // otherwise. + let mut page0_size = output_size; + + let mut page_sizes: Vec = vec![0; pages.len() + 1]; + + let sorted_pages_vec = { + let mut v: Vec<(&usize, &PublicMemoryPage)> = pages.iter().collect(); + v.sort_by_key(|x| x.0); + v + }; + + for (index, (page_id, page)) in sorted_pages_vec.iter().cloned().enumerate() { + if *page_id != expected_page_id { + return Err(PageError::UnexpectedPageId(expected_page_id, *page_id)); + } + + if *page_id == 1 { + if page.start > output_size { + return Err(PageError::InvalidPageStart(page.start)); + } + page0_size = page.start; + } else if page.start != expected_page_start { + return Err(PageError::UnexpectedPageStart( + expected_page_start, + page.start, + )); + } + + page_sizes[index + 1] = page.size; + expected_page_start = page.start + page.size; + expected_page_id += 1; + } + + if !pages.is_empty() { + // The loop above did not cover the whole output range + if expected_page_start != output_size { + return Err(PageError::OutputNotFullyCovered); + } + } + + page_sizes[0] = page0_size; + Ok(page_sizes) +} + +fn get_fact_topology_from_additional_data( + output_size: usize, + output_builtin_additional_data: &OutputBuiltinAdditionalData, +) -> Result { + let tree_structure = get_tree_structure_from_output_data(output_builtin_additional_data)?; + let page_sizes = get_page_sizes_from_pages(output_size, &output_builtin_additional_data.pages)?; + + Ok(FactTopology { + tree_structure, + page_sizes, + }) +} + +// TODO: implement for CairoPieTask +fn get_program_task_fact_topology( + output_size: usize, + output_builtin: &mut OutputBuiltinRunner, + output_runner_data: OutputBuiltinState, +) -> Result { + let additional_data = match output_builtin.get_additional_data() { + BuiltinAdditionalData::Output(data) => data, + other => { + return Err(FactTopologyError::Internal( + format!( + "Additional data of output builtin is not of the expected type: {:?}", + other + ) + .into_boxed_str(), + )) + } + }; + let fact_topology = get_fact_topology_from_additional_data(output_size, &additional_data)?; + output_builtin.set_state(output_runner_data); + + Ok(fact_topology) +} + +pub fn get_task_fact_topology( + output_size: usize, + task: &Task, + output_builtin: &mut OutputBuiltinRunner, + output_runner_data: Option, +) -> Result { + match task { + Task::Program(_program) => { + let output_runner_data = output_runner_data.ok_or(FactTopologyError::Internal( + "Output runner data not set for program task" + .to_string() + .into_boxed_str(), + ))?; + get_program_task_fact_topology(output_size, output_builtin, output_runner_data) + } + Task::Pie(cairo_pie) => { + if output_runner_data.is_some() { + return Err(FactTopologyError::Internal( + "Output runner data set for Cairo PIE task" + .to_string() + .into_boxed_str(), + )); + } + let additional_data = { + let additional_data = cairo_pie + .additional_data + .0 + .get(&BuiltinName::output) + .ok_or(FactTopologyError::CairoPieHasNoOutputBuiltinData)?; + match additional_data { + BuiltinAdditionalData::Output(output_data) => output_data, + _ => { + return Err(FactTopologyError::CairoPieHasNoOutputBuiltinData); + } + } + }; + + get_fact_topology_from_additional_data(output_size, additional_data) + } + } +} + +/// Writes fact topologies to a file, as JSON. +/// +/// * `path`: File path. +/// * `fact_topologies`: Fact topologies to write. +pub fn write_to_fact_topologies_file>( + path: &Path, + fact_topologies: &[FT], +) -> Result<(), WriteFactTopologiesError> { + let mut file = File::create(path)?; + let fact_topology_file = FactTopologyFile { + fact_topologies: fact_topologies.iter().map(|ft| ft.as_ref()).collect(), + }; + serde_json::to_writer(&mut file, &fact_topology_file)?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use std::collections::HashMap; + + use crate::hints::types::CompositePackedOutput; + use rstest::{fixture, rstest}; + + use super::*; + + #[fixture] + fn packed_outputs() -> Vec { + vec![ + PackedOutput::Plain(vec![]), + PackedOutput::Plain(vec![]), + PackedOutput::Plain(vec![]), + ] + } + + #[fixture] + fn fact_topologies() -> Vec { + vec![ + FactTopology { + tree_structure: vec![], + page_sizes: vec![1usize], + }, + FactTopology { + tree_structure: vec![], + page_sizes: vec![1usize, 2usize], + }, + FactTopology { + tree_structure: vec![], + page_sizes: vec![3usize], + }, + ] + } + + #[rstest] + fn test_compute_fact_topologies( + packed_outputs: Vec, + fact_topologies: Vec, + ) { + let plain_fact_topologies = compute_fact_topologies(&packed_outputs, &fact_topologies) + .expect("Failed to compute fact topologies"); + for (topology, plain_topology) in std::iter::zip(&fact_topologies, plain_fact_topologies) { + assert_eq!(topology, plain_topology); + } + } + + #[test] + /// Composite outputs are not supported (yet). + fn test_compute_fact_topologies_composite_output() { + let packed_outputs = vec![PackedOutput::Composite(CompositePackedOutput::default())]; + let fact_topologies = vec![FactTopology { + tree_structure: vec![], + page_sizes: vec![], + }]; + let result = compute_fact_topologies(&packed_outputs, &fact_topologies); + assert!(matches!( + result, + Err(FactTopologyError::CompositePackedOutputNotSupported(_)) + )); + } + + #[test] + /// Both arguments to `compute_fact_topologies` must have the same length. + fn test_compute_fact_topologies_arg_len_mismatch() { + let packed_outputs = vec![PackedOutput::Plain(vec![])]; + let fact_topologies = vec![]; + + let result = compute_fact_topologies(&packed_outputs, &fact_topologies); + assert!( + matches!(result, Err(FactTopologyError::WrongNumberOfFactTopologies(n_outputs, n_topologies)) if n_outputs == packed_outputs.len() && n_topologies == fact_topologies.len()) + ) + } + + #[rstest] + fn test_add_consecutive_output_pages() { + let fact_topology = FactTopology { + tree_structure: vec![], + page_sizes: vec![1usize, 2usize, 1usize], + }; + let mut output_builtin = OutputBuiltinRunner::new(true); + let page_id = 1; + let output_start = Relocatable { + segment_index: 0, + offset: 10, + }; + + let result = add_consecutive_output_pages( + &fact_topology, + &mut output_builtin, + page_id, + output_start, + ) + .expect("Adding consecutive output pages failed unexpectedly"); + assert_eq!(result, fact_topology.page_sizes.len()); + + let output_builtin_state = output_builtin.get_state(); + assert_eq!( + output_builtin_state.pages, + HashMap::from([ + (1, PublicMemoryPage { start: 10, size: 1 }), + (2, PublicMemoryPage { start: 11, size: 2 }), + (3, PublicMemoryPage { start: 13, size: 1 }) + ]) + ); + } + + #[rstest] + fn test_configure_fact_topologies(fact_topologies: Vec) { + let mut output_builtin = OutputBuiltinRunner::new(true); + let mut output_start = Relocatable { + segment_index: output_builtin.base() as isize, + offset: 10, + }; + + let result = + configure_fact_topologies(&fact_topologies, &mut output_start, &mut output_builtin) + .expect("Configuring fact topologies failed unexpectedly"); + + assert_eq!(result, ()); + + // We expect the offset to 2 + sum(page_sizes) for each fact topology + let expected_offset: usize = fact_topologies.iter().flat_map(|ft| &ft.page_sizes).sum(); + let expected_offset = expected_offset + fact_topologies.len() * 2; + assert_eq!(output_start.segment_index, output_builtin.base() as isize); + assert_eq!(output_start.offset, 10 + expected_offset); + + let output_builtin_state = output_builtin.get_state(); + assert_eq!( + output_builtin_state.pages, + HashMap::from([ + (1, PublicMemoryPage { start: 12, size: 1 }), + (2, PublicMemoryPage { start: 15, size: 1 }), + (3, PublicMemoryPage { start: 16, size: 2 }), + (4, PublicMemoryPage { start: 20, size: 3 }) + ]) + ); + } + + #[test] + fn test_get_tree_structure() { + let expected_tree_structure = vec![7, 12, 4, 0]; + + let output_builtin_data = OutputBuiltinAdditionalData { + pages: HashMap::new(), + attributes: HashMap::from([( + GPS_FACT_TOPOLOGY.to_string(), + expected_tree_structure.clone(), + )]), + }; + + let tree_structure = get_tree_structure_from_output_data(&output_builtin_data) + .expect("Failed to get tree structure"); + assert_eq!(tree_structure, expected_tree_structure); + } + + #[test] + fn test_get_tree_structure_default() { + let output_builtin_data = OutputBuiltinAdditionalData { + pages: HashMap::new(), + attributes: HashMap::new(), + }; + + let tree_structure = get_tree_structure_from_output_data(&output_builtin_data) + .expect("Failed to get tree structure"); + assert_eq!(tree_structure, vec![1, 0]); + } + + #[rstest] + #[case::uneven_tree(vec![1, 3, 7])] + #[case::tree_too_long(vec![1; 12])] + #[case::value_too_large(vec![0, 1073741825])] // 1073741825 = 2^30 + 1 + fn test_get_tree_structure_invalid_tree(#[case] tree_structure: Vec) { + let output_builtin_data = OutputBuiltinAdditionalData { + pages: HashMap::new(), + attributes: HashMap::from([(GPS_FACT_TOPOLOGY.to_string(), tree_structure.clone())]), + }; + + let result = get_tree_structure_from_output_data(&output_builtin_data); + assert!(matches!( + result, + Err(TreeStructureError::InvalidTreeStructure) + )); + } + + #[test] + fn test_get_tree_structure_default_with_pages() { + let output_builtin_data = OutputBuiltinAdditionalData { + pages: HashMap::from([(1, PublicMemoryPage { start: 0, size: 10 })]), + attributes: HashMap::new(), + }; + + let result = get_tree_structure_from_output_data(&output_builtin_data); + assert!(matches!( + result, + Err(TreeStructureError::CannotUseAdditionalPages) + )); + } + + #[test] + fn test_get_page_sizes_from_pages() { + let output_size = 10usize; + let pages = HashMap::from([ + (1, PublicMemoryPage { start: 0, size: 7 }), + (2, PublicMemoryPage { start: 7, size: 3 }), + ]); + + let page_sizes = + get_page_sizes_from_pages(output_size, &pages).expect("Could not compute page sizes"); + assert_eq!(page_sizes, vec![0, 7, 3]); + } + + #[test] + fn test_get_page_sizes_missing() { + let output_size = 10usize; + let page_sizes = get_page_sizes_from_pages(output_size, &HashMap::new()) + .expect("Could not compute page sizes"); + assert_eq!(page_sizes, vec![output_size]); + } + + #[test] + fn test_get_page_sizes_unexpected_page_id() { + let output_size = 10usize; + let pages = HashMap::from([ + (1, PublicMemoryPage { start: 0, size: 7 }), + (3, PublicMemoryPage { start: 7, size: 3 }), + ]); + + let result = get_page_sizes_from_pages(output_size, &pages); + assert!(matches!(result, Err(PageError::UnexpectedPageId(2, 3)))); + } + + #[test] + fn test_get_page_sizes_invalid_page_start() { + let output_size = 10usize; + let pages = HashMap::from([ + (1, PublicMemoryPage { start: 12, size: 7 }), + (2, PublicMemoryPage { start: 19, size: 3 }), + ]); + + let result = get_page_sizes_from_pages(output_size, &pages); + assert!(matches!(result, Err(PageError::InvalidPageStart(12)))); + } + + #[test] + fn test_get_page_sizes_unexpected_page_start() { + let output_size = 10usize; + let pages = HashMap::from([ + (1, PublicMemoryPage { start: 0, size: 7 }), + (2, PublicMemoryPage { start: 8, size: 3 }), + ]); + + let result = get_page_sizes_from_pages(output_size, &pages); + assert!(matches!(result, Err(PageError::UnexpectedPageStart(7, 8)))); + } + + #[test] + fn test_get_page_sizes_output_not_fully_covered() { + let output_size = 10usize; + let pages = HashMap::from([ + (1, PublicMemoryPage { start: 0, size: 7 }), + (2, PublicMemoryPage { start: 7, size: 2 }), + ]); + + let result = get_page_sizes_from_pages(output_size, &pages); + assert!(matches!(result, Err(PageError::OutputNotFullyCovered))); + } +} diff --git a/src/hints/hint_processor.rs b/src/hints/hint_processor.rs new file mode 100644 index 0000000..bb26763 --- /dev/null +++ b/src/hints/hint_processor.rs @@ -0,0 +1,115 @@ +use std::any::Any; +use std::collections::HashMap; + +use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData; +use cairo_vm::hint_processor::builtin_hint_processor::memcpy_hint_utils::exit_scope; +use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; +use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::vm_core::VirtualMachine; +use cairo_vm::Felt252; + +use crate::hints::bootloader_hints::{ + assert_is_composite_packed_output, assert_program_address, + compute_and_configure_fact_topologies, enter_packed_output_scope, + guess_pre_image_of_subtasks_output_hash, import_packed_output_schemas, is_plain_packed_output, + load_bootloader_config, prepare_simple_bootloader_input, + prepare_simple_bootloader_output_segment, restore_bootloader_output, save_output_pointer, + save_packed_outputs, set_packed_output_to_subtasks, +}; +use crate::hints::codes::*; +use crate::hints::execute_task_hints::{ + allocate_program_data_segment, append_fact_topologies, call_task, load_program_hint, + validate_hash, write_return_builtins_hint, +}; +use crate::hints::inner_select_builtins::select_builtin; +use crate::hints::select_builtins::select_builtins_enter_scope; +use crate::hints::simple_bootloader_hints::{ + divide_num_by_2, prepare_task_range_checks, set_ap_to_zero, set_current_task, + set_tasks_variable, +}; + +pub struct BootloaderHintProcessor; + +impl HintProcessorLogic for BootloaderHintProcessor { + fn execute_hint( + &mut self, + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + hint_data: &Box, + _constants: &HashMap, + ) -> Result<(), HintError> { + let hint_data = hint_data + .downcast_ref::() + .ok_or(HintError::WrongHintData)?; + + let ids_data = &hint_data.ids_data; + let ap_tracking = &hint_data.ap_tracking; + + match hint_data.code.as_str() { + BOOTLOADER_RESTORE_BOOTLOADER_OUTPUT => restore_bootloader_output(vm, exec_scopes), + BOOTLOADER_PREPARE_SIMPLE_BOOTLOADER_INPUT => { + prepare_simple_bootloader_input(exec_scopes) + } + BOOTLOADER_LOAD_BOOTLOADER_CONFIG => { + load_bootloader_config(vm, exec_scopes, ids_data, ap_tracking) + } + BOOTLOADER_ENTER_PACKED_OUTPUT_SCOPE => { + enter_packed_output_scope(vm, exec_scopes, ids_data, ap_tracking) + } + BOOTLOADER_SAVE_OUTPUT_POINTER => { + save_output_pointer(vm, exec_scopes, ids_data, ap_tracking) + } + BOOTLOADER_SAVE_PACKED_OUTPUTS => save_packed_outputs(exec_scopes), + BOOTLOADER_GUESS_PRE_IMAGE_OF_SUBTASKS_OUTPUT_HASH => { + guess_pre_image_of_subtasks_output_hash(vm, exec_scopes, ids_data, ap_tracking) + } + BOOTLOADER_PREPARE_SIMPLE_BOOTLOADER_OUTPUT_SEGMENT => { + prepare_simple_bootloader_output_segment(vm, exec_scopes, ids_data, ap_tracking) + } + BOOTLOADER_COMPUTE_FACT_TOPOLOGIES => { + compute_and_configure_fact_topologies(vm, exec_scopes) + } + BOOTLOADER_SET_PACKED_OUTPUT_TO_SUBTASKS => set_packed_output_to_subtasks(exec_scopes), + BOOTLOADER_IMPORT_PACKED_OUTPUT_SCHEMAS => import_packed_output_schemas(), + BOOTLOADER_IS_PLAIN_PACKED_OUTPUT => is_plain_packed_output(vm, exec_scopes), + BOOTLOADER_ASSERT_IS_COMPOSITE_PACKED_OUTPUT => { + assert_is_composite_packed_output(exec_scopes) + } + SIMPLE_BOOTLOADER_PREPARE_TASK_RANGE_CHECKS => { + prepare_task_range_checks(vm, exec_scopes, ids_data, ap_tracking) + } + SIMPLE_BOOTLOADER_SET_TASKS_VARIABLE => set_tasks_variable(exec_scopes), + SIMPLE_BOOTLOADER_DIVIDE_NUM_BY_2 => divide_num_by_2(vm, ids_data, ap_tracking), + SIMPLE_BOOTLOADER_SET_CURRENT_TASK => { + set_current_task(vm, exec_scopes, ids_data, ap_tracking) + } + SIMPLE_BOOTLOADER_ZERO => set_ap_to_zero(vm), + EXECUTE_TASK_ALLOCATE_PROGRAM_DATA_SEGMENT => { + allocate_program_data_segment(vm, exec_scopes, ids_data, ap_tracking) + } + EXECUTE_TASK_LOAD_PROGRAM => load_program_hint(vm, exec_scopes, ids_data, ap_tracking), + EXECUTE_TASK_VALIDATE_HASH => validate_hash(vm, exec_scopes, ids_data, ap_tracking), + EXECUTE_TASK_ASSERT_PROGRAM_ADDRESS => { + assert_program_address(vm, exec_scopes, ids_data, ap_tracking) + } + EXECUTE_TASK_CALL_TASK => call_task(vm, exec_scopes, ids_data, ap_tracking), + EXECUTE_TASK_WRITE_RETURN_BUILTINS => { + write_return_builtins_hint(vm, exec_scopes, ids_data, ap_tracking) + } + EXECUTE_TASK_EXIT_SCOPE => exit_scope(exec_scopes), + EXECUTE_TASK_APPEND_FACT_TOPOLOGIES => { + append_fact_topologies(vm, exec_scopes, ids_data, ap_tracking) + } + SELECT_BUILTINS_ENTER_SCOPE => { + select_builtins_enter_scope(vm, exec_scopes, ids_data, ap_tracking) + } + INNER_SELECT_BUILTINS_SELECT_BUILTIN => { + select_builtin(vm, exec_scopes, ids_data, ap_tracking) + } + unknown_hint_code => Err(HintError::UnknownHint( + unknown_hint_code.to_string().into_boxed_str(), + )), + } + } +} diff --git a/src/hints/inner_select_builtins.rs b/src/hints/inner_select_builtins.rs new file mode 100644 index 0000000..e6936fa --- /dev/null +++ b/src/hints/inner_select_builtins.rs @@ -0,0 +1,116 @@ +use cairo_vm::Felt252; +use std::collections::HashMap; + +use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{ + get_ptr_from_var_name, insert_value_from_var_name, +}; +use cairo_vm::hint_processor::hint_processor_definition::HintReference; +use cairo_vm::serde::deserialize_program::ApTracking; +use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::vm_core::VirtualMachine; + +use crate::hints::vars; + +/// Sets ids.select_builtin to 1 if the first builtin should be selected and 0 otherwise. +/// +/// Implements +/// # A builtin should be selected iff its encoding appears in the selected encodings list +/// # and the list wasn't exhausted. +/// # Note that testing inclusion by a single comparison is possible since the lists are sorted. +/// ids.select_builtin = int( +/// n_selected_builtins > 0 and memory[ids.selected_encodings] == memory[ids.all_encodings]) +/// if ids.select_builtin: +/// n_selected_builtins = n_selected_builtins - 1 +pub fn select_builtin( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let n_selected_builtins: usize = exec_scopes.get(vars::N_SELECTED_BUILTINS)?; + + let select_builtin = if n_selected_builtins == 0 { + false + } else { + let selected_encodings = + get_ptr_from_var_name("selected_encodings", vm, ids_data, ap_tracking)?; + let all_encodings = get_ptr_from_var_name("all_encodings", vm, ids_data, ap_tracking)?; + + let selected_encoding = vm.get_integer(selected_encodings)?.into_owned(); + let builtin_encoding = vm.get_integer(all_encodings)?.into_owned(); + + selected_encoding == builtin_encoding + }; + + let select_builtin_felt = Felt252::from(select_builtin); + insert_value_from_var_name( + "select_builtin", + select_builtin_felt, + vm, + ids_data, + ap_tracking, + )?; + + if select_builtin { + exec_scopes.insert_value(vars::N_SELECTED_BUILTINS, n_selected_builtins - 1); + } + + Ok(()) +} + +#[cfg(test)] +mod tests { + use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_integer_from_var_name; + use cairo_vm::Felt252; + use rstest::rstest; + + use super::*; + + #[rstest] + #[case::should_select_builtin(1usize, true)] + #[case::should_not_select_builtin(1usize, false)] + #[case::no_builtins(0usize, true)] + fn test_select_builtin(#[case] n_builtins: usize, #[case] should_select_builtin: bool) { + let mut vm = vm!(); + + let builtin_value = 10; + let expected_value = if should_select_builtin { + builtin_value + } else { + builtin_value + 1 + }; + + vm.segments = segments![ + ((1, 0), (2, 0)), + ((1, 1), (2, 1)), + ((2, 0), builtin_value), + ((2, 1), expected_value) + ]; + // Allocate space for program_data_ptr + vm.run_context.fp = 3; + add_segments!(vm, 2); + let ids_data = ids_data!["selected_encodings", "all_encodings", "select_builtin"]; + let ap_tracking = ApTracking::new(); + + let mut exec_scopes = ExecutionScopes::new(); + exec_scopes.insert_value(vars::N_SELECTED_BUILTINS, n_builtins); + + select_builtin(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Hint failed unexpectedly"); + + let select_builtin = + get_integer_from_var_name("select_builtin", &vm, &ids_data, &ap_tracking) + .unwrap() + .into_owned(); + let n_selected_builtins: usize = exec_scopes.get(vars::N_SELECTED_BUILTINS).unwrap(); + + if (n_builtins != 0) && should_select_builtin { + assert_eq!(select_builtin, Felt252::from(1)); + assert_eq!(n_selected_builtins, n_builtins - 1); + } else { + assert_eq!(select_builtin, Felt252::from(0)); + assert_eq!(n_selected_builtins, n_builtins); + } + } +} diff --git a/src/hints/load_cairo_pie.rs b/src/hints/load_cairo_pie.rs new file mode 100644 index 0000000..8dd946f --- /dev/null +++ b/src/hints/load_cairo_pie.rs @@ -0,0 +1,384 @@ +use std::collections::HashMap; + +use cairo_vm::types::builtin_name::BuiltinName; +use cairo_vm::types::errors::math_errors::MathError; +use cairo_vm::types::relocatable::{MaybeRelocatable, Relocatable}; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::errors::memory_errors::MemoryError; +use cairo_vm::vm::runners::builtin_runner::SignatureBuiltinRunner; +use cairo_vm::vm::runners::cairo_pie::{BuiltinAdditionalData, CairoPie, CairoPieMemory}; +use cairo_vm::vm::vm_core::VirtualMachine; +use cairo_vm::Felt252; +use thiserror_no_std::Error; + +#[derive(Error, Debug)] +pub enum RelocationTableError { + #[error(transparent)] + Math(#[from] MathError), + + #[error(transparent)] + Memory(#[from] MemoryError), + + #[error("Expected relocatable to point to the start of a segment: {0}")] + ExpectedSegmentBase(Relocatable), + + #[error("Segment index already present in the relocation table: {0}")] + SegmentAlreadyMapped(isize), +} + +#[derive(Error, Debug)] +pub enum SignatureRelocationError { + #[error(transparent)] + Memory(#[from] MemoryError), + + #[error("The PIE requires ECDSA but the VM is not configured to use it")] + EcdsaBuiltinNotFound, + + #[error("Relocated signature data ({0} not on signature builtin segment {1}")] + RelocatedDataNotOnBuiltinSegment(Relocatable, isize), + + #[error("The Cairo PIE ECDSA builtin data is not in the expected format")] + InvalidCairoPieEcdsaBuiltinData, +} + +#[derive(Error, Debug)] +pub enum MemoryRelocationError { + #[error(transparent)] + Memory(#[from] MemoryError), +} + +#[derive(Error, Debug)] +pub enum CairoPieLoaderError { + #[error("Error while building relocation table: {0}")] + RelocationTable(#[from] RelocationTableError), + + #[error("Error while relocating signature builtin data: {0}")] + SignatureRelocation(#[from] SignatureRelocationError), + + #[error("Error while relocating Cairo PIE memory: {0}")] + MemoryRelocationError(#[from] MemoryRelocationError), +} + +impl From for HintError { + fn from(value: CairoPieLoaderError) -> Self { + HintError::CustomHint(value.to_string().into_boxed_str()) + } +} + +/// Keeps track of relocations for different segments. +/// +/// Each entry in `relocations` maps a segment index from the PIE to +/// a pointer in the VM memory. +pub struct RelocationTable { + relocations: HashMap, +} + +impl RelocationTable { + pub fn new() -> Self { + Self { + relocations: Default::default(), + } + } + + /// Inserts an entry in the relocations map. + /// + /// * `segment_index`: Index of the Cairo PIE segment. + /// * `relocation`: Destination in the VM memory. + /// + /// Returns `SegmentAlreadyMapped` if a relocation entry already exists for + /// `segment_index`. + pub fn insert( + &mut self, + segment_index: isize, + relocation: Relocatable, + ) -> Result<(), RelocationTableError> { + if self.relocations.contains_key(&segment_index) { + return Err(RelocationTableError::SegmentAlreadyMapped(segment_index)); + } + self.relocations.insert(segment_index, relocation); + + Ok(()) + } + + /// Relocates a pointer. + /// + /// Considering a relocatable (i, o), if a relocation table entry i -> (i*, o*) exists, + /// returns (i*, o + o*). + /// Returns `MemoryError::Relocation` if there is no matching relocation. + pub fn relocate_address(&self, address: Relocatable) -> Result { + let new_base = self + .relocations + .get(&address.segment_index) + .ok_or(MemoryError::Relocation)?; + + let relocated_pointer = (*new_base + address.offset)?; + Ok(relocated_pointer) + } + + /// Relocates any value. + /// + /// Returns the value directly if it is an integer, otherwise returns the relocated address + /// using `relocate_address`. + pub fn relocate_value(&self, value: MaybeRelocatable) -> Result { + match value { + MaybeRelocatable::Int(_) => Ok(value), + MaybeRelocatable::RelocatableValue(address) => { + let relocated_addr = self.relocate_address(address); + relocated_addr.map(MaybeRelocatable::RelocatableValue) + } + } + } +} + +/// Returns the segment index for the given value. +/// Verifies that value is a RelocatableValue with offset 0. +pub fn extract_segment(maybe_relocatable: MaybeRelocatable) -> Result { + match maybe_relocatable { + MaybeRelocatable::RelocatableValue(address) => { + if address.offset != 0 { + return Err(RelocationTableError::ExpectedSegmentBase(address)); + } + + Ok(address.segment_index) + } + MaybeRelocatable::Int(_) => Err(RelocationTableError::Memory( + MemoryError::AddressNotRelocatable, + )), + } +} + +/// Builds a hashmap of address -> value from the `CairoPieMemory` vector. +/// +/// Makes it more convenient to access values in the Cairo PIE memory. +fn build_cairo_pie_memory_map(memory: &CairoPieMemory) -> HashMap { + let mut memory_map: HashMap = HashMap::new(); + + for ((segment_index, offset), value) in memory.0.iter() { + let address = Relocatable::from((*segment_index as isize, *offset)); + memory_map.insert(address, value); + } + + memory_map +} + +/// Builds a relocation table for the specified Cairo PIE. +pub fn build_cairo_pie_relocation_table( + cairo_pie: &CairoPie, + vm: &mut VirtualMachine, + program_address: Relocatable, + execution_segment_address: Relocatable, + ret_fp: Relocatable, + ret_pc: Relocatable, +) -> Result { + let mut relocation_table = RelocationTable::new(); + + relocation_table.insert(cairo_pie.metadata.program_segment.index, program_address)?; + relocation_table.insert( + cairo_pie.metadata.execution_segment.index, + execution_segment_address, + )?; + relocation_table.insert(cairo_pie.metadata.ret_fp_segment.index, ret_fp)?; + relocation_table.insert(cairo_pie.metadata.ret_pc_segment.index, ret_pc)?; + + let origin_execution_segment = Relocatable { + segment_index: cairo_pie.metadata.execution_segment.index, + offset: 0, + }; + + // Create a hashmap of the program memory for easier searching. + // If this turns out to be too expensive, consider building it directly + // when building the CairoPie object. + let memory_map = build_cairo_pie_memory_map(&cairo_pie.memory); + + // Set initial stack relocations. + for (idx, _builtin_name) in cairo_pie.metadata.program.builtins.iter().enumerate() { + let memory_address = (origin_execution_segment + idx)?; + let segment_index = extract_segment(memory_map[&memory_address].clone())?; + let relocation = vm.get_relocatable((execution_segment_address + idx)?)?; + relocation_table.insert(segment_index, relocation)?; + } + + for segment_info in cairo_pie.metadata.extra_segments.iter() { + relocation_table.insert(segment_info.index, vm.add_memory_segment())?; + } + + Ok(relocation_table) +} + +fn extend_additional_data( + builtin: &mut SignatureBuiltinRunner, + data: &HashMap, + relocation_table: &RelocationTable, +) -> Result<(), SignatureRelocationError> { + for (addr, signature) in data { + let relocated_addr = relocation_table.relocate_address(*addr)?; + let builtin_segment_base = builtin.base() as isize; + if relocated_addr.segment_index != builtin_segment_base { + return Err(SignatureRelocationError::RelocatedDataNotOnBuiltinSegment( + relocated_addr, + builtin_segment_base, + )); + } + builtin.add_signature(*addr, signature)?; + } + + Ok(()) +} + +/// Relocate builtin additional data. +/// This should occur before the memory relocation, since the signature builtin assumes that a +/// signature is added before the corresponding public key and message are both written to memory. +fn relocate_builtin_additional_data( + cairo_pie: &CairoPie, + vm: &mut VirtualMachine, + relocation_table: &RelocationTable, +) -> Result<(), SignatureRelocationError> { + let ecdsa_additional_data = match cairo_pie.additional_data.0.get(&BuiltinName::ecdsa) { + Some(BuiltinAdditionalData::Signature(data)) => data, + Some(_) => return Err(SignatureRelocationError::InvalidCairoPieEcdsaBuiltinData), + _ => return Ok(()), + }; + + let ecdsa_builtin = vm + .get_signature_builtin() + .map_err(|_| SignatureRelocationError::EcdsaBuiltinNotFound)?; + + extend_additional_data(ecdsa_builtin, ecdsa_additional_data, relocation_table)?; + + Ok(()) +} + +/// Relocates the memory of the PIE. +/// +/// * `cairo_pie`: Cairo PIE. +/// * `vm`: Virtual machine. +/// * `relocation_table`: Relocation rules. +fn relocate_cairo_pie_memory( + cairo_pie: &CairoPie, + vm: &mut VirtualMachine, + relocation_table: &RelocationTable, +) -> Result<(), MemoryRelocationError> { + // Relocate memory segment + for ((segment_index, offset), value) in &cairo_pie.memory.0 { + let address = Relocatable::from((*segment_index as isize, *offset)); + let relocated_address = relocation_table.relocate_address(address)?; + let relocated_value = relocation_table.relocate_value(value.clone())?; + + vm.insert_value(relocated_address, relocated_value)?; + } + + Ok(()) +} + +/// Load memory entries of the inner program. +/// +/// Relocates (copies) the memory of the PIE to segments allocated for the current task. +/// This replaces executing hints in a non-trusted program. +pub(crate) fn load_cairo_pie( + cairo_pie: &CairoPie, + vm: &mut VirtualMachine, + program_address: Relocatable, + execution_segment_address: Relocatable, + ret_fp: Relocatable, + ret_pc: Relocatable, +) -> Result<(), CairoPieLoaderError> { + let relocation_table = build_cairo_pie_relocation_table( + cairo_pie, + vm, + program_address, + execution_segment_address, + ret_fp, + ret_pc, + )?; + + relocate_builtin_additional_data(cairo_pie, vm, &relocation_table)?; + relocate_cairo_pie_memory(cairo_pie, vm, &relocation_table)?; + + Ok(()) +} + +#[cfg(test)] +mod tests { + use assert_matches::assert_matches; + + use super::*; + + #[test] + fn test_relocate_value() { + let relocation_table = RelocationTable::new(); + + let value = MaybeRelocatable::Int(Felt252::from(64)); + assert_eq!(relocation_table.relocate_value(value.clone()), Ok(value)); + } + + #[test] + fn test_relocate_address() { + let mut relocation_table = RelocationTable::new(); + let relocation = Relocatable::from((2, 5)); + relocation_table.insert(1, relocation.clone()).unwrap(); + + let address = Relocatable::from((1, 27)); + let expected_address = Relocatable::from((2, 32)); + assert_eq!( + relocation_table.relocate_address(address), + Ok(expected_address) + ); + + let value = MaybeRelocatable::RelocatableValue(address); + let expected_value = MaybeRelocatable::RelocatableValue(expected_address); + assert_eq!(relocation_table.relocate_value(value), Ok(expected_value)); + } + + #[test] + fn test_relocate_address_no_matching_relocation() { + let relocation_table = RelocationTable::new(); + + let value = MaybeRelocatable::RelocatableValue(Relocatable::from((1, 0))); + assert_eq!( + relocation_table.relocate_value(value.clone()), + Err(MemoryError::Relocation) + ); + } + + #[test] + fn test_relocation_table_write_twice() { + let segment_index = 1; + let relocation = Relocatable::from((2, 0)); + + let mut relocation_table = RelocationTable::new(); + relocation_table.insert(segment_index, relocation).unwrap(); + + let new_relocation = Relocatable::from((3, 0)); + + let result = relocation_table.insert(segment_index, new_relocation); + assert_matches!( + result, + Err(RelocationTableError::SegmentAlreadyMapped(idx)) if idx == segment_index + ); + } + + #[test] + fn test_extract_segment_base() { + let address = Relocatable::from((1, 0)); + let result = extract_segment(MaybeRelocatable::RelocatableValue(address)).unwrap(); + assert_eq!(result, address.segment_index); + } + + #[test] + fn test_extract_segment_base_not_a_base() { + let address = Relocatable::from((1, 5)); + let result = extract_segment(MaybeRelocatable::RelocatableValue(address)); + assert_matches!(result, Err(RelocationTableError::ExpectedSegmentBase(relocatable)) if relocatable == address); + } + + #[test] + fn test_extract_segment_base_not_an_address() { + let result = extract_segment(MaybeRelocatable::Int(Felt252::from(1))); + assert_matches!( + result, + Err(RelocationTableError::Memory( + MemoryError::AddressNotRelocatable + )) + ); + } +} diff --git a/src/hints/mod.rs b/src/hints/mod.rs new file mode 100644 index 0000000..7dbe4f6 --- /dev/null +++ b/src/hints/mod.rs @@ -0,0 +1,13 @@ +mod bootloader_hints; +mod codes; +mod execute_task_hints; +mod fact_topologies; +pub mod hint_processor; +mod inner_select_builtins; +mod load_cairo_pie; +mod program_hash; +mod program_loader; +mod select_builtins; +mod simple_bootloader_hints; +mod types; +mod vars; diff --git a/src/hints/program_hash.rs b/src/hints/program_hash.rs new file mode 100644 index 0000000..ac50c60 --- /dev/null +++ b/src/hints/program_hash.rs @@ -0,0 +1,199 @@ +use cairo_vm::types::builtin_name::BuiltinName; +use cairo_vm::types::relocatable::MaybeRelocatable; +use cairo_vm::vm::runners::cairo_pie::StrippedProgram; +use cairo_vm::Felt252; +use starknet_crypto::{pedersen_hash, FieldElement}; + +type HashFunction = fn(&FieldElement, &FieldElement) -> FieldElement; + +#[derive(thiserror_no_std::Error, Debug)] +pub enum HashChainError { + #[error("Data array must contain at least one element.")] + EmptyData, +} + +#[derive(thiserror_no_std::Error, Debug)] +pub enum ProgramHashError { + #[error(transparent)] + HashChain(#[from] HashChainError), + + #[error( + "Invalid program builtin: builtin name too long to be converted to field element: {0}" + )] + InvalidProgramBuiltin(&'static str), + + #[error("Invalid program data: data contains relocatable(s)")] + InvalidProgramData, + + /// Conversion from Felt252 to FieldElement failed. This is unlikely to happen + /// unless the implementation of Felt252 changes and this code is not updated properly. + #[error("Conversion from Felt252 to FieldElement failed")] + Felt252ToFieldElementConversionFailed, +} + +/// Computes a hash chain over the data, in the following order: +/// h(data[0], h(data[1], h(..., h(data[n-2], data[n-1])))). +/// +/// Reimplements this Python function: +/// def compute_hash_chain(data, hash_func=pedersen_hash): +/// assert len(data) >= 1, f"len(data) for hash chain computation must be >= 1; got: {len(data)}." +/// return functools.reduce(lambda x, y: hash_func(y, x), data[::-1]) +fn compute_hash_chain<'a, I>( + data: I, + hash_func: HashFunction, +) -> Result +where + I: Iterator + DoubleEndedIterator, +{ + match data.copied().rev().reduce(|x, y| hash_func(&y, &x)) { + Some(result) => Ok(result), + None => Err(HashChainError::EmptyData), + } +} + +/// Creates an instance of `FieldElement` from a builtin name. +/// +/// Converts the builtin name to bytes then attempts to create a field element from +/// these bytes. This function will fail if the builtin name is over 31 characters. +fn builtin_to_field_element(builtin: &BuiltinName) -> Result { + // The Python implementation uses the builtin name without suffix + let builtin_name = builtin.to_str(); + + FieldElement::from_byte_slice_be(builtin_name.as_bytes()) + .map_err(|_| ProgramHashError::InvalidProgramBuiltin(builtin.to_str())) +} + +/// The `value: FieldElement` is `pub(crate)` and there is no accessor. +/// This function converts a `Felt252` to a `FieldElement` using a safe, albeit inefficient, +/// method. +fn felt_to_field_element(felt: &Felt252) -> Result { + let bytes = felt.to_bytes_be(); + FieldElement::from_bytes_be(&bytes) + .map_err(|_e| ProgramHashError::Felt252ToFieldElementConversionFailed) +} + +/// Converts a `MaybeRelocatable` into a `FieldElement` value. +/// +/// Returns `InvalidProgramData` if `maybe_relocatable` is not an integer +fn maybe_relocatable_to_field_element( + maybe_relocatable: &MaybeRelocatable, +) -> Result { + let felt = maybe_relocatable + .get_int_ref() + .ok_or(ProgramHashError::InvalidProgramData)?; + felt_to_field_element(felt) +} + +#[allow(dead_code)] // TODO: remove +/// Computes the Pedersen hash of a program. +/// +/// Reimplements this Python function: +/// def compute_program_hash_chain(program: ProgramBase, bootloader_version=0): +/// builtin_list = [from_bytes(builtin.encode("ascii")) for builtin in program.builtins] +/// # The program header below is missing the data length, which is later added to the data_chain. +/// program_header = [bootloader_version, program.main, len(program.builtins)] + builtin_list +/// data_chain = program_header + program.data +/// +/// return compute_hash_chain([len(data_chain)] + data_chain) +pub fn compute_program_hash_chain( + program: &StrippedProgram, + bootloader_version: usize, +) -> Result { + let program_main = program.main; + let program_main = FieldElement::from(program_main); + + // Convert builtin names to field elements + let builtin_list: Result, _> = program + .builtins + .iter() + .map(builtin_to_field_element) + .collect(); + let builtin_list = builtin_list?; + + let program_header = vec![ + FieldElement::from(bootloader_version), + program_main, + FieldElement::from(program.builtins.len()), + ]; + + let program_data: Result, _> = program + .data + .iter() + .map(maybe_relocatable_to_field_element) + .collect(); + let program_data = program_data?; + + let data_chain_len = program_header.len() + builtin_list.len() + program_data.len(); + let data_chain_len_vec = vec![FieldElement::from(data_chain_len)]; + + // Prepare a chain of iterators to feed to the hash function + let data_chain = [ + &data_chain_len_vec, + &program_header, + &builtin_list, + &program_data, + ]; + + let hash = compute_hash_chain(data_chain.iter().flat_map(|&v| v.iter()), pedersen_hash)?; + Ok(hash) +} + +#[cfg(test)] +mod tests { + use std::path::PathBuf; + + use cairo_vm::types::program::Program; + use rstest::rstest; + use starknet_crypto::pedersen_hash; + + use super::*; + + #[test] + fn test_compute_hash_chain() { + let data: Vec = vec![ + FieldElement::from(1u64), + FieldElement::from(2u64), + FieldElement::from(3u64), + ]; + let expected_hash = pedersen_hash( + &FieldElement::from(1u64), + &pedersen_hash(&FieldElement::from(2u64), &FieldElement::from(3u64)), + ); + let computed_hash = compute_hash_chain(data.iter(), pedersen_hash) + .expect("Hash computation failed unexpectedly"); + + assert_eq!(computed_hash, expected_hash); + } + + #[rstest] + // Expected hashes generated with `cairo-hash-program` + #[case::fibonacci( + "../cairo_programs/fibonacci.json", + "0x43b17e9592f33142246af4c06cd2b574b460dd1f718d76b51341175a62b220f" + )] + #[case::field_arithmetic( + "../cairo_programs/field_arithmetic.json", + "0x1031772ca86e618b058101af9c9a3277bac90712b750bcea1cc69d6c7cad8a7" + )] + #[case::keccak_copy_inputs( + "../cairo_programs/keccak_copy_inputs.json", + "0x49484fdc8e7a85061f9f21b7e21fe276d8a88c8e96681101a2518809e686c6c" + )] + fn test_compute_program_hash_chain( + #[case] program_path: PathBuf, + #[case] expected_program_hash: String, + ) { + let program = + Program::from_file(program_path.as_path(), Some("main")) + .expect("Could not load program. Did you compile the sample programs? Run `make test` in the root directory."); + let stripped_program = program.get_stripped_program().unwrap(); + let bootloader_version = 0; + + let program_hash = compute_program_hash_chain(&stripped_program, bootloader_version) + .expect("Failed to compute program hash."); + + let program_hash_hex = format!("{:#x}", program_hash); + + assert_eq!(program_hash_hex, expected_program_hash); + } +} diff --git a/src/hints/program_loader.rs b/src/hints/program_loader.rs new file mode 100644 index 0000000..e36e178 --- /dev/null +++ b/src/hints/program_loader.rs @@ -0,0 +1,345 @@ +use cairo_vm::types::builtin_name::BuiltinName; +use cairo_vm::types::errors::math_errors::MathError; +use cairo_vm::types::relocatable::Relocatable; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::errors::memory_errors::MemoryError; +use cairo_vm::vm::runners::cairo_pie::StrippedProgram; +use cairo_vm::vm::vm_core::VirtualMachine; +use cairo_vm::Felt252; + +use crate::hints::types::BootloaderVersion; + +#[derive(thiserror_no_std::Error, Debug)] +pub enum ProgramLoaderError { + #[error(transparent)] + Math(#[from] MathError), + + #[error(transparent)] + Memory(#[from] MemoryError), +} + +impl From for HintError { + fn from(value: ProgramLoaderError) -> Self { + match value { + ProgramLoaderError::Math(e) => HintError::Math(e), + ProgramLoaderError::Memory(e) => HintError::Memory(e), + } + } +} + +/// Creates an instance of `Felt252` from a builtin name. +/// +/// Converts the builtin name to bytes then attempts to create a felt from +/// these bytes. This function will fail if the builtin name is over 31 characters. +/// +/// This is used by the loader to make the builtins used by the program to the Cairo +/// code. +fn builtin_to_felt(builtin: &BuiltinName) -> Result { + // The Python implementation uses the builtin name without suffix + let builtin_name = builtin.to_str(); + + Ok(Felt252::from_bytes_be_slice(builtin_name.as_bytes())) +} + +pub struct LoadedProgram { + /// Start of the program code in the VM memory. + pub code_address: Relocatable, + /// Total size of the program in memory, header included. + pub size: usize, +} + +/// Loads a Cairo program in the VM memory. +pub struct ProgramLoader<'vm> { + /// Memory accessor. + vm: &'vm mut VirtualMachine, + /// Offset of the builtin list array in the Cairo VM memory. + builtins_offset: usize, +} + +impl<'vm> ProgramLoader<'vm> { + pub fn new(vm: &'vm mut VirtualMachine, builtins_offset: usize) -> Self { + Self { + vm, + builtins_offset, + } + } + + fn load_builtins( + &mut self, + builtin_list_ptr: Relocatable, + builtins: &[BuiltinName], + ) -> Result<(), ProgramLoaderError> { + for (index, builtin) in builtins.iter().enumerate() { + let builtin_felt = builtin_to_felt(builtin)?; + self.vm + .insert_value((builtin_list_ptr + index)?, builtin_felt)?; + } + + Ok(()) + } + + fn load_header( + &mut self, + base_address: Relocatable, + program: &StrippedProgram, + bootloader_version: Option, + ) -> Result { + // Map the header struct as memory addresses + let data_length_ptr = base_address; + let bootloader_version_ptr = (base_address + 1)?; + let program_main_ptr = (base_address + 2)?; + let n_builtins_ptr = (base_address + 3)?; + let builtin_list_ptr = (base_address + 4)?; + + let program_data = &program.data; + + let builtins = &program.builtins; + let n_builtins = builtins.len(); + let header_size = self.builtins_offset + n_builtins; + + // data_length does not include the data_length header field in the calculation. + let data_length = header_size - 1 + program_data.len(); + let program_main = program.main; + + let bootloader_version = bootloader_version.unwrap_or(0); + + self.vm.insert_value(data_length_ptr, data_length)?; + self.vm + .insert_value(bootloader_version_ptr, Felt252::from(bootloader_version))?; + self.vm.insert_value(program_main_ptr, program_main)?; + self.vm.insert_value(n_builtins_ptr, n_builtins)?; + + self.load_builtins(builtin_list_ptr, builtins)?; + + Ok(header_size) + } + + fn load_code( + &mut self, + base_address: Relocatable, + program: &StrippedProgram, + ) -> Result<(), ProgramLoaderError> { + for (index, opcode) in program.data.iter().enumerate() { + self.vm.insert_value((base_address + index)?, opcode)?; + } + + Ok(()) + } + + /// Loads a Cairo program in the VM memory. + /// + /// Programs are loaded in two parts: + /// 1. The program header contains metadata (ex: entrypoint, program size, + /// builtins used by the program). + /// 2. The program itself. + /// + /// Starting from `base_address`, the header contains the following fields: + /// 1. The size of the header + /// 2. The bootloader version + /// 3. The program entrypoint + /// 4. The number of builtins used by the program + /// 5. The list of builtins used (converted to felts) as a C-style array. + /// + /// * `base_address`: Where to load the program, see above. + /// * `program`: The program to load. + /// * `bootloader_version`: The bootloader version. Defaults to 0. + /// + /// Returns the address where the code of the program is loaded and the program size. + pub fn load_program( + &mut self, + base_address: Relocatable, + program: &StrippedProgram, + bootloader_version: Option, + ) -> Result { + let header_size = self.load_header(base_address, program, bootloader_version)?; + + let program_address = (base_address + header_size)?; + self.load_code(program_address, program)?; + + Ok(LoadedProgram { + code_address: program_address, + size: header_size + program.data.len(), + }) + } +} + +#[cfg(test)] +mod tests { + use std::any::Any; + + use cairo_vm::types::builtin_name::BuiltinName; + use cairo_vm::types::program::Program; + use cairo_vm::types::relocatable::Relocatable; + use cairo_vm::vm::runners::cairo_pie::StrippedProgram; + use cairo_vm::vm::vm_memory::memory_segments::MemorySegmentManager; + use cairo_vm::Felt252; + use num_traits::ToPrimitive; + use rstest::{fixture, rstest}; + use serde::Serialize; + + use crate::hints::types::BootloaderVersion; + + use super::*; + + #[rstest] + #[case::output(BuiltinName::output, 122550255383924)] + #[case::pedersen(BuiltinName::pedersen, 8098989891770344814)] + fn test_builtin_to_felt(#[case] builtin_name: BuiltinName, #[case] expected_value: u64) { + let expected_felt = Felt252::from(expected_value); + let felt = builtin_to_felt(&builtin_name).unwrap(); + + assert_eq!(felt, expected_felt); + } + + fn check_loaded_builtins( + vm: &VirtualMachine, + builtins: &[&str], + builtin_list_ptr: Relocatable, + ) { + let builtin_felts = vm + .get_integer_range(builtin_list_ptr, builtins.len()) + .expect("Builtins not loaded properly in memory"); + for (builtin, felt) in std::iter::zip(vec!["bitwise", "output", "pedersen"], builtin_felts) + { + let builtin_from_felt = String::from_utf8(felt.into_owned().to_bytes_be().to_vec()) + .expect( + format!( + "Could not decode builtin from memory (expected {})", + builtin + ) + .as_ref(), + ); + // Compare the last N characters, builtin_from_felt is padded left with zeroes + assert_eq!(&builtin_from_felt[32 - builtin.len()..32], builtin); + } + } + + #[test] + fn test_load_builtins() { + let builtins = vec![ + BuiltinName::bitwise, + BuiltinName::output, + BuiltinName::pedersen, + ]; + + let mut vm = VirtualMachine::new(false); + let builtin_list_ptr = vm.add_memory_segment(); + + let builtins_offset = 4; + let mut program_loader = ProgramLoader::new(&mut vm, builtins_offset); + + program_loader + .load_builtins(builtin_list_ptr, &builtins) + .expect("Failed to load builtins in memory"); + + check_loaded_builtins( + &vm, + &vec!["bitwise", "output", "pedersen"], + builtin_list_ptr, + ); + } + + #[fixture] + fn fibonacci() -> Program { + let program_content = + include_bytes!("../../../../../cairo_programs/fibonacci.json").to_vec(); + + Program::from_bytes(&program_content, Some("main")) + .expect("Loading example program failed unexpectedly") + } + + fn check_loaded_header( + vm: &VirtualMachine, + header_address: Relocatable, + program: &StrippedProgram, + bootloader_version: BootloaderVersion, + ) { + let header_felts = vm.get_integer_range(header_address, 4).unwrap(); + let expected_data_length = program.data.len() + 3; + let program_main = program.main; + let n_builtins = program.builtins.len(); + + assert_eq!( + header_felts[0].clone().into_owned(), + Felt252::from(expected_data_length) + ); + assert_eq!( + header_felts[1].clone().into_owned(), + Felt252::from(bootloader_version) + ); + assert_eq!( + header_felts[2].clone().into_owned(), + Felt252::from(program_main) + ); + assert_eq!( + header_felts[3].clone().into_owned(), + Felt252::from(n_builtins) + ); + } + + #[rstest] + fn test_load_header(fibonacci: Program) { + let program = fibonacci.get_stripped_program().unwrap(); + + let mut vm = VirtualMachine::new(false); + let mut segments = MemorySegmentManager::new(); + let base_address = segments.add(); + + let builtins_offset = 4; + let mut program_loader = ProgramLoader::new(&mut vm, builtins_offset); + + let bootloader_version: BootloaderVersion = 0; + program_loader + .load_header(base_address, &program, Some(bootloader_version)) + .expect("Failed to load program header in memory"); + + check_loaded_header(&vm, base_address.clone(), &program, bootloader_version); + + let builtin_list_ptr = (base_address + builtins_offset)?; + check_loaded_builtins(&vm, &vec![], builtin_list_ptr); + } + + fn check_loaded_program( + vm: &VirtualMachine, + code_address: Relocatable, + program: &StrippedProgram, + ) { + let loaded_opcodes = vm + .get_continuous_range(code_address, program.data.len()) + .expect("Program not loaded properly in memory"); + + for (loaded, original) in std::iter::zip(loaded_opcodes, &program.data) { + assert_eq!(loaded, *original); + } + } + + #[rstest] + fn test_load_program(fibonacci: Program) { + let program = fibonacci.get_stripped_program().unwrap(); + + let mut vm = VirtualMachine::new(false); + let mut segments = MemorySegmentManager::new(); + let base_address = segments.add(); + + let builtins_offset = 4; + let mut program_loader = ProgramLoader::new(&mut vm, builtins_offset); + + let bootloader_version: BootloaderVersion = 0; + let loaded_program = program_loader + .load_program(base_address, &program, Some(bootloader_version)) + .expect("Failed to load program in memory"); + + let header_size = builtins_offset + program.builtins.len(); + let expected_code_address = (base_address + header_size).unwrap(); + assert_eq!(loaded_program.code_address, expected_code_address); + + assert_eq!(loaded_program.size, header_size + program.data.len()); + + check_loaded_program(&vm, loaded_program.code_address, &program); + + check_loaded_header(&vm, base_address.clone(), &program, bootloader_version); + + let builtin_list_ptr = (base_address + builtins_offset).unwrap(); + check_loaded_builtins(&vm, &vec![], builtin_list_ptr); + } +} diff --git a/src/hints/select_builtins.rs b/src/hints/select_builtins.rs new file mode 100644 index 0000000..dcb2666 --- /dev/null +++ b/src/hints/select_builtins.rs @@ -0,0 +1,79 @@ +use std::any::Any; +use std::collections::HashMap; + +use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_integer_from_var_name; +use cairo_vm::hint_processor::hint_processor_definition::HintReference; +use cairo_vm::serde::deserialize_program::ApTracking; +use cairo_vm::types::errors::math_errors::MathError; +use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::vm_core::VirtualMachine; +use num_traits::ToPrimitive; + +use crate::hints::vars; + +/// Implements +/// %{ vm_enter_scope({'n_selected_builtins': ids.n_selected_builtins}) %} +pub fn select_builtins_enter_scope( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let n_selected_builtins = + get_integer_from_var_name(vars::N_SELECTED_BUILTINS, vm, ids_data, ap_tracking)?; + let n_selected_builtins = + n_selected_builtins + .to_usize() + .ok_or(MathError::Felt252ToUsizeConversion(Box::new( + n_selected_builtins, + )))?; + + exec_scopes.enter_scope(HashMap::from([( + vars::N_SELECTED_BUILTINS.to_string(), + Box::new(n_selected_builtins) as Box, + )])); + + Ok(()) +} + +#[cfg(test)] +mod tests { + use std::any::Any; + use std::collections::HashMap; + + use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_integer_from_var_name; + use cairo_vm::hint_processor::hint_processor_definition::HintReference; + use cairo_vm::serde::deserialize_program::ApTracking; + use cairo_vm::types::exec_scope::ExecutionScopes; + use cairo_vm::vm::errors::hint_errors::HintError; + use cairo_vm::vm::vm_core::VirtualMachine; + use num_traits::ToPrimitive; + use serde::Serialize; + + use super::*; + + #[test] + fn test_select_builtins_enter_scope() { + let mut vm = vm!(); + // Set n_selected_builtins to 7 + vm.run_context.fp = 1; + vm.segments = segments![((1, 0), 7)]; + let ids_data = ids_data![vars::N_SELECTED_BUILTINS]; + let n_selected_builtins = 7usize; + + let ap_tracking = ApTracking::default(); + let mut exec_scopes = ExecutionScopes::new(); + + select_builtins_enter_scope(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Hint failed unexpectedly"); + + // Check that we entered a new scope + assert_eq!(exec_scopes.data.len(), 2); + assert_eq!(exec_scopes.data[1].len(), 1); + + let n_selected_builtins_var: usize = exec_scopes.get(vars::N_SELECTED_BUILTINS).unwrap(); + + assert_eq!(n_selected_builtins_var, n_selected_builtins); + } +} diff --git a/src/hints/simple_bootloader_hints.rs b/src/hints/simple_bootloader_hints.rs new file mode 100644 index 0000000..c473226 --- /dev/null +++ b/src/hints/simple_bootloader_hints.rs @@ -0,0 +1,325 @@ +use std::collections::HashMap; + +use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{ + get_integer_from_var_name, get_ptr_from_var_name, insert_value_from_var_name, + insert_value_into_ap, +}; +use cairo_vm::hint_processor::hint_processor_definition::HintReference; +use cairo_vm::serde::deserialize_program::ApTracking; +use cairo_vm::types::errors::math_errors::MathError; +use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::vm_core::VirtualMachine; +use cairo_vm::Felt252; +use num_traits::ToPrimitive; +use starknet_types_core::felt::NonZeroFelt; + +use crate::hints::fact_topologies::FactTopology; +use crate::hints::types::SimpleBootloaderInput; +use crate::hints::vars; + +/// Implements +/// n_tasks = len(simple_bootloader_input.tasks) +/// memory[ids.output_ptr] = n_tasks +/// +/// # Task range checks are located right after simple bootloader validation range checks, and +/// # this is validated later in this function. +/// ids.task_range_check_ptr = ids.range_check_ptr + ids.BuiltinData.SIZE * n_tasks +/// +/// # A list of fact_toplogies that instruct how to generate the fact from the program output +/// # for each task. +/// fact_topologies = [] +pub fn prepare_task_range_checks( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + // n_tasks = len(simple_bootloader_input.tasks) + let simple_bootloader_input: &SimpleBootloaderInput = + exec_scopes.get_ref(vars::SIMPLE_BOOTLOADER_INPUT)?; + let n_tasks = simple_bootloader_input.tasks.len(); + + // memory[ids.output_ptr] = n_tasks + let output_ptr = get_ptr_from_var_name("output_ptr", vm, ids_data, ap_tracking)?; + vm.insert_value(output_ptr, Felt252::from(n_tasks))?; + + // ids.task_range_check_ptr = ids.range_check_ptr + ids.BuiltinData.SIZE * n_tasks + // BuiltinData is a struct with 8 members defined in execute_task.cairo. + const BUILTIN_DATA_SIZE: usize = 8; + let range_check_ptr = get_ptr_from_var_name("range_check_ptr", vm, ids_data, ap_tracking)?; + let task_range_check_ptr = (range_check_ptr + BUILTIN_DATA_SIZE * n_tasks)?; + insert_value_from_var_name( + "task_range_check_ptr", + task_range_check_ptr, + vm, + ids_data, + ap_tracking, + )?; + + // fact_topologies = [] + let fact_topologies = Vec::::new(); + exec_scopes.insert_value(vars::FACT_TOPOLOGIES, fact_topologies); + + Ok(()) +} + +/// Implements +/// %{ tasks = simple_bootloader_input.tasks %} +pub fn set_tasks_variable(exec_scopes: &mut ExecutionScopes) -> Result<(), HintError> { + let simple_bootloader_input: &SimpleBootloaderInput = + exec_scopes.get_ref(vars::SIMPLE_BOOTLOADER_INPUT)?; + exec_scopes.insert_value(vars::TASKS, simple_bootloader_input.tasks.clone()); + + Ok(()) +} + +/// Implements %{ ids.num // 2 %} +/// (compiled to %{ memory[ap] = to_felt_or_relocatable(ids.num // 2) %}). +pub fn divide_num_by_2( + vm: &mut VirtualMachine, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let felt = get_integer_from_var_name("num", vm, ids_data, ap_tracking)?; + // Unwrapping is safe in this context, 2 != 0 + let two = NonZeroFelt::try_from(Felt252::from(2)).unwrap(); + let felt_divided_by_2 = felt.floor_div(&two); + + insert_value_into_ap(vm, felt_divided_by_2)?; + + Ok(()) +} + +/// Implements %{ 0 %} (compiled to %{ memory[ap] = to_felt_or_relocatable(0) %}). +/// +/// Stores 0 in the AP and returns. +/// Used as `tempvar use_poseidon = nondet %{ 0 %}`. +pub fn set_ap_to_zero(vm: &mut VirtualMachine) -> Result<(), HintError> { + insert_value_into_ap(vm, Felt252::from(0))?; + Ok(()) +} + +/// Implements +/// from starkware.cairo.bootloaders.simple_bootloader.objects import Task +/// +/// # Pass current task to execute_task. +/// task_id = len(simple_bootloader_input.tasks) - ids.n_tasks +/// task = simple_bootloader_input.tasks[task_id].load_task() +pub fn set_current_task( + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let simple_bootloader_input: &SimpleBootloaderInput = + exec_scopes.get_ref(vars::SIMPLE_BOOTLOADER_INPUT)?; + let n_tasks_felt = get_integer_from_var_name("n_tasks", vm, ids_data, ap_tracking)?; + let n_tasks = n_tasks_felt + .to_usize() + .ok_or(MathError::Felt252ToUsizeConversion(Box::new(n_tasks_felt)))?; + + let task_id = simple_bootloader_input.tasks.len() - n_tasks; + // TODO: it's still unclear how we need to model TaskSpec/Task objects. + // Check if we need to keep TaskSpec, or if it needs to be implemented as a trait, etc. + let task = simple_bootloader_input.tasks[task_id].load_task(); + + exec_scopes.insert_value(vars::TASK, task.clone()); + + Ok(()) +} + +#[cfg(test)] +mod tests { + use std::any::Any; + use std::collections::HashMap; + use std::collections::HashMap; + + use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{ + get_ptr_from_var_name, get_relocatable_from_var_name, insert_value_from_var_name, + }; + use cairo_vm::hint_processor::hint_processor_definition::HintReference; + use cairo_vm::serde::deserialize_program::{ApTracking, BuiltinName, Identifier}; + use cairo_vm::types::exec_scope::ExecutionScopes; + use cairo_vm::types::program::Program; + use cairo_vm::types::relocatable::{MaybeRelocatable, Relocatable}; + use cairo_vm::vm::errors::hint_errors::HintError; + use cairo_vm::vm::errors::memory_errors::MemoryError; + use cairo_vm::vm::runners::builtin_runner::OutputBuiltinRunner; + use cairo_vm::vm::runners::cairo_pie::{ + CairoPie, OutputBuiltinAdditionalData, StrippedProgram, + }; + use cairo_vm::vm::vm_core::VirtualMachine; + use cairo_vm::vm::vm_memory::memory::Memory; + use cairo_vm::{any_box, Felt252}; + use num_traits::ToPrimitive; + use num_traits::ToPrimitive; + use rstest::{fixture, rstest}; + use starknet_crypto::FieldElement; + + use crate::hints::fact_topologies::{get_task_fact_topology, FactTopology}; + use crate::hints::load_cairo_pie::load_cairo_pie; + use crate::hints::program_hash::compute_program_hash_chain; + use crate::hints::program_loader::ProgramLoader; + use crate::hints::types::{BootloaderVersion, Task, TaskSpec}; + use crate::hints::vars; + + use super::*; + + #[fixture] + fn fibonacci() -> Program { + let program_content = + include_bytes!("../../../../../cairo_programs/fibonacci.json").to_vec(); + + Program::from_bytes(&program_content, Some("main")) + .expect("Loading example program failed unexpectedly") + } + + #[fixture] + fn simple_bootloader_input(fibonacci: Program) -> SimpleBootloaderInput { + SimpleBootloaderInput { + fact_topologies_path: None, + single_page: false, + tasks: vec![ + TaskSpec { + task: Task::Program(fibonacci.clone()), + }, + TaskSpec { + task: Task::Program(fibonacci.clone()), + }, + ], + } + } + + #[rstest] + fn test_prepare_task_range_checks(simple_bootloader_input: SimpleBootloaderInput) { + let mut vm = vm!(); + vm.run_context.fp = 3; + vm.segments = segments![((1, 0), (2, 0)), ((1, 1), (2, 2))]; + let ids_data = ids_data!["output_ptr", "range_check_ptr", "task_range_check_ptr"]; + vm.add_memory_segment(); + + let mut exec_scopes = ExecutionScopes::new(); + exec_scopes.insert_value( + vars::SIMPLE_BOOTLOADER_INPUT, + simple_bootloader_input.clone(), + ); + + let ap_tracking = ApTracking::new(); + + prepare_task_range_checks(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Hint failed unexpectedly"); + + let task_range_check_ptr = + get_ptr_from_var_name("task_range_check_ptr", &mut vm, &ids_data, &ap_tracking) + .unwrap(); + + // Assert *output_ptr == n_tasks + let output = vm + .segments + .memory + .get_integer(Relocatable { + segment_index: 2, + offset: 0, + }) + .unwrap() + .to_usize() + .unwrap(); + assert_eq!(output, simple_bootloader_input.tasks.len()); + + // Assert task_range_check_ptr == range_check_ptr (2, 2) + BUILTIN_DATA_SIZE (8) * n_tasks (2) + assert_eq!( + task_range_check_ptr, + Relocatable { + segment_index: 2, + offset: 18 + } + ); + + let fact_topologies: Vec = exec_scopes + .get(vars::FACT_TOPOLOGIES) + .expect("Fact topologies missing from scope"); + assert!(fact_topologies.is_empty()); + } + + #[rstest] + fn test_set_tasks_variable(simple_bootloader_input: SimpleBootloaderInput) { + let bootloader_tasks = simple_bootloader_input.tasks.clone(); + + let mut exec_scopes = ExecutionScopes::new(); + exec_scopes.insert_value(vars::SIMPLE_BOOTLOADER_INPUT, simple_bootloader_input); + + set_tasks_variable(&mut exec_scopes).expect("Hint failed unexpectedly"); + + let tasks: Vec = exec_scopes + .get(vars::TASKS) + .expect("Tasks variable is not set"); + assert_eq!(tasks, bootloader_tasks); + } + + #[rstest] + #[case(128u128, 64u128)] + #[case(1001u128, 500u128)] + fn test_divide_num_by_2(#[case] num: u128, #[case] expected: u128) { + let num_felt = Felt252::from(num); + let expected_num_felt = Felt252::from(expected); + + let mut vm = vm!(); + add_segments!(vm, 2); + vm.run_context.ap = 1; + vm.run_context.fp = 1; + + let ids_data = ids_data!["num"]; + let ap_tracking = ApTracking::new(); + + insert_value_from_var_name("num", num_felt, &mut vm, &ids_data, &ap_tracking).unwrap(); + + divide_num_by_2(&mut vm, &ids_data, &ap_tracking).expect("Hint failed unexpectedly"); + + let divided_num = vm + .segments + .memory + .get_integer(vm.run_context.get_ap()) + .unwrap(); + assert_eq!(divided_num.into_owned(), expected_num_felt); + } + + #[rstest] + fn test_set_to_zero() { + let mut vm = vm!(); + add_segments!(vm, 2); + + set_ap_to_zero(&mut vm).expect("Hint failed unexpectedly"); + + let ap_value = vm + .segments + .memory + .get_integer(vm.run_context.get_ap()) + .unwrap() + .into_owned(); + + assert_eq!(ap_value, Felt252::from(0)); + } + + #[rstest] + fn test_set_current_task(simple_bootloader_input: SimpleBootloaderInput) { + // Set n_tasks to 1 + let mut vm = vm!(); + vm.run_context.fp = 2; + vm.segments = segments![((1, 0), 1)]; + + let mut exec_scopes = ExecutionScopes::new(); + exec_scopes.insert_value(vars::SIMPLE_BOOTLOADER_INPUT, simple_bootloader_input); + + let ids_data = ids_data!["n_tasks", "task"]; + let ap_tracking = ApTracking::new(); + + set_current_task(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) + .expect("Hint failed unexpectedly"); + + // Check that `task` is set + let _task: Task = exec_scopes + .get(vars::TASK) + .expect("task variable is not set."); + } +} diff --git a/src/hints/types.rs b/src/hints/types.rs new file mode 100644 index 0000000..256d9ce --- /dev/null +++ b/src/hints/types.rs @@ -0,0 +1,81 @@ +use std::collections::HashMap; +use std::path::PathBuf; + +use cairo_vm::serde::deserialize_program::Identifier; +use cairo_vm::types::errors::program_errors::ProgramError; +use cairo_vm::types::program::Program; +use cairo_vm::vm::runners::cairo_pie::{CairoPie, StrippedProgram}; +use cairo_vm::Felt252; +use serde::Deserialize; + +pub type BootloaderVersion = u64; + +pub(crate) type ProgramIdentifiers = HashMap; + +#[derive(Deserialize, Debug, Clone, PartialEq)] +pub struct BootloaderConfig { + pub simple_bootloader_program_hash: Felt252, + pub supported_cairo_verifier_program_hashes: Vec, +} + +#[derive(Deserialize, Debug, Default, Clone, PartialEq)] +pub struct CompositePackedOutput { + pub outputs: Vec, + pub subtasks: Vec, +} + +impl CompositePackedOutput { + pub fn elements_for_hash(&self) -> &Vec { + &self.outputs + } +} + +#[derive(Deserialize, Debug, Clone, PartialEq)] +pub enum PackedOutput { + Plain(Vec), + Composite(CompositePackedOutput), +} + +#[derive(Debug, Clone, PartialEq)] +#[allow(clippy::large_enum_variant)] +#[allow(dead_code)] // for now until we integrate an example +pub enum Task { + Program(Program), + Pie(CairoPie), +} + +impl Task { + pub fn get_program(&self) -> Result { + // TODO: consider whether declaring a struct similar to StrippedProgram + // but that uses a reference to data to avoid copying is worth the effort. + match self { + Task::Program(program) => program.get_stripped_program(), + Task::Pie(cairo_pie) => Ok(cairo_pie.metadata.program.clone()), + } + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct TaskSpec { + pub task: Task, +} + +impl TaskSpec { + pub fn load_task(&self) -> &Task { + &self.task + } +} + +#[derive(Debug, Clone, PartialEq)] +pub struct SimpleBootloaderInput { + pub fact_topologies_path: Option, + pub single_page: bool, + pub tasks: Vec, +} + +#[derive(Debug, Clone, PartialEq)] +pub struct BootloaderInput { + pub simple_bootloader_input: SimpleBootloaderInput, + pub bootloader_config: BootloaderConfig, + pub packed_outputs: Vec, +} diff --git a/src/hints/vars.rs b/src/hints/vars.rs new file mode 100644 index 0000000..92a8514 --- /dev/null +++ b/src/hints/vars.rs @@ -0,0 +1,47 @@ +/// Deserialized bootloader input. +pub(crate) const BOOTLOADER_INPUT: &str = "bootloader_input"; + +/// The bootloader program, as a Program object. +pub(crate) const BOOTLOADER_PROGRAM_IDENTIFIERS: &str = "bootloader_program"; + +/// Saved state of the output builtin. +pub(crate) const OUTPUT_BUILTIN_STATE: &str = "output_builtin_state"; + +/// Output builtin segment start. +pub(crate) const OUTPUT_START: &str = "output_start"; + +/// Deserialized simple bootloader input. +pub(crate) const SIMPLE_BOOTLOADER_INPUT: &str = "simple_bootloader_input"; + +/// Packed outputs. +pub(crate) const PACKED_OUTPUTS: &str = "packed_outputs"; + +/// Packed output for the current task. +pub(crate) const PACKED_OUTPUT: &str = "packed_output"; + +/// Fact topologies. +pub(crate) const FACT_TOPOLOGIES: &str = "fact_topologies"; + +/// Simple bootloader tasks. +pub(crate) const TASKS: &str = "tasks"; + +/// Current simple bootloader task. +pub(crate) const TASK: &str = "task"; + +/// Program data segment. Used in `execute_task()`. +pub(crate) const PROGRAM_DATA_BASE: &str = "program_data_base"; + +/// Address of current program. +pub(crate) const PROGRAM_ADDRESS: &str = "program_address"; + +/// Output builtin additional data. +pub(crate) const OUTPUT_RUNNER_DATA: &str = "output_runner_data"; + +/// Number of builtins used by the program. +pub(crate) const N_BUILTINS: &str = "n_builtins"; + +/// Number of selected builtins for the current program. +pub(crate) const N_SELECTED_BUILTINS: &str = "n_selected_builtins"; + +/// "pre_execution_builtin_ptrs" +pub(crate) const PRE_EXECUTION_BUILTIN_PTRS: &str = "pre_execution_builtin_ptrs"; diff --git a/src/lib.rs b/src/lib.rs new file mode 100644 index 0000000..17ad9cc --- /dev/null +++ b/src/lib.rs @@ -0,0 +1 @@ +pub mod hints; From c10fc8d533a4bd605bdb6fefd71670b0f316910b Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Thu, 23 May 2024 12:12:39 +0200 Subject: [PATCH 02/28] Add cairo-lang as dependency --- .gitmodules | 3 +++ dependencies/cairo-lang | 1 + 2 files changed, 4 insertions(+) create mode 100644 .gitmodules create mode 160000 dependencies/cairo-lang diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..c0ee744 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "dependencies/cairo-lang"] + path = dependencies/cairo-lang + url = https://github.com/starkware-libs/cairo-lang diff --git a/dependencies/cairo-lang b/dependencies/cairo-lang new file mode 160000 index 0000000..efa9648 --- /dev/null +++ b/dependencies/cairo-lang @@ -0,0 +1 @@ +Subproject commit efa9648f57568aad8f8a13fbf027d2de7c63c2c0 From 18da9bf509a8912896c3278728ac1ecf91b1fa1b Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Thu, 23 May 2024 12:12:50 +0200 Subject: [PATCH 03/28] wip readme --- Cargo.toml | 4 +--- README.md | 51 +++++++++++++++++++++++++++++++++++++++++++++- src/hints/mod.rs | 5 ++++- src/hints/types.rs | 1 - src/lib.rs | 2 ++ 5 files changed, 57 insertions(+), 6 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 859d9b0..7fcd23c 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -cairo-vm = { version = "1.0.0-rc3", features = ["extensive_hints"] } +cairo-vm = { git = "https://github.com/lambdaclass/cairo-vm", rev = "5e8b9d4a2aacbdd284ff3a9dea6bb6e6d669ee1e", features = ["extensive_hints"] } num-traits = "0.2.19" serde = { version = "1.0.202", features = ["derive"] } serde_json = "1.0.117" @@ -19,5 +19,3 @@ thiserror-no-std = "2.0.2" assert_matches = "1.5.0" rstest = "0.19.0" -[patch.crates-io] -cairo-vm = { path = "../cairo-vm/vm" } diff --git a/README.md b/README.md index 4e62d55..6918c0c 100644 --- a/README.md +++ b/README.md @@ -1,2 +1,51 @@ -# cairo-bootloader +# Cairo bootloader + Cairo bootloader port for the Rust Cairo VM. + +The Cairo bootloader is a Cairo program that loads and executes other programs in a provable way. +It is also able to execute Cairo PIEs (Position Independent Executables) along with regular Cairo programs. + +## How to use this library + +Add this library to your dependencies, then launch your programs this way: + +```rust +use cairo_bootloader::BootloaderHintProcessor; +use cairo_vm::types::program::Program; + +fn run_program_with_bootloader(bootloader_program: &Program, program: &Program) -> Result<(), HintError> { + let proof_mode = true; + let layout = layout.unwrap_or(Layout::StarknetWithKeccak); + + let cairo_run_config = CairoRunConfig { + entrypoint: "main", + trace_enabled: true, + relocate_mem: true, + layout: &layout.to_string(), + proof_mode, + secure_run: None, + disable_trace_padding: false, + allow_missing_builtins, + }; + + let n_tasks = tasks.len(); + + let bootloader_input = BootloaderInput { + simple_bootloader_input: SimpleBootloaderInput { + fact_topologies_path, + single_page: false, + tasks, + }, + bootloader_config: BootloaderConfig { + simple_bootloader_program_hash: Felt252::from(0), + supported_cairo_verifier_program_hashes: vec![], + }, + packed_outputs: vec![PackedOutput::Plain(vec![]); n_tasks], + }; +} +``` + +## Limitations + +* Composite packed outputs are not supported yet. +* The bootloader is not able to load hints for Cairo 0 programs with hints yet. diff --git a/src/hints/mod.rs b/src/hints/mod.rs index 7dbe4f6..4cc0bd7 100644 --- a/src/hints/mod.rs +++ b/src/hints/mod.rs @@ -2,7 +2,7 @@ mod bootloader_hints; mod codes; mod execute_task_hints; mod fact_topologies; -pub mod hint_processor; +mod hint_processor; mod inner_select_builtins; mod load_cairo_pie; mod program_hash; @@ -11,3 +11,6 @@ mod select_builtins; mod simple_bootloader_hints; mod types; mod vars; + +pub use hint_processor::BootloaderHintProcessor; +pub use types::{SimpleBootloaderInput, Task, TaskSpec}; diff --git a/src/hints/types.rs b/src/hints/types.rs index 256d9ce..065d09a 100644 --- a/src/hints/types.rs +++ b/src/hints/types.rs @@ -38,7 +38,6 @@ pub enum PackedOutput { #[derive(Debug, Clone, PartialEq)] #[allow(clippy::large_enum_variant)] -#[allow(dead_code)] // for now until we integrate an example pub enum Task { Program(Program), Pie(CairoPie), diff --git a/src/lib.rs b/src/lib.rs index 17ad9cc..8f2c85f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1 +1,3 @@ pub mod hints; + +pub use hints::*; From bf827da7f81ad2cefb7133078caa32207ed36312 Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Fri, 24 May 2024 14:59:28 +0200 Subject: [PATCH 04/28] add bootloader --- .github/workflows/check.yml | 1 - Cargo.toml | 2 +- examples/fibonacci.json | 717 + examples/run_program.rs | 136 + resources/bootloader-0.13.1.json | 35810 +++++++++++++++++++++++++++++ scripts/compile-bootloader.sh | 32 + src/hints/hint_processor.rs | 9 + src/hints/mod.rs | 6 +- src/hints/vars.rs | 32 +- src/lib.rs | 19 + src/tasks.rs | 38 + 11 files changed, 36783 insertions(+), 19 deletions(-) create mode 100644 examples/fibonacci.json create mode 100644 examples/run_program.rs create mode 100644 resources/bootloader-0.13.1.json create mode 100644 scripts/compile-bootloader.sh create mode 100644 src/tasks.rs diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index 201207f..74fc658 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -36,7 +36,6 @@ jobs: # with: # python-version: '3.11' # - run: | - # pip install cairo-lang==0.13.1 # bash ./scripts/reset-tests.sh # RUSTFLAGS="-D warnings" cargo test diff --git a/Cargo.toml b/Cargo.toml index 7fcd23c..7bb5d0a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,7 @@ edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -cairo-vm = { git = "https://github.com/lambdaclass/cairo-vm", rev = "5e8b9d4a2aacbdd284ff3a9dea6bb6e6d669ee1e", features = ["extensive_hints"] } +cairo-vm = { git = "https://github.com/lambdaclass/cairo-vm", rev = "feb7b248ccfb082b2e898b387f8f474fa3e170d0", features = ["extensive_hints"] } num-traits = "0.2.19" serde = { version = "1.0.202", features = ["derive"] } serde_json = "1.0.117" diff --git a/examples/fibonacci.json b/examples/fibonacci.json new file mode 100644 index 0000000..b23ccac --- /dev/null +++ b/examples/fibonacci.json @@ -0,0 +1,717 @@ +{ + "attributes": [], + "builtins": [], + "compiler_version": "0.12.0", + "data": [ + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0xa", + "0x1104800180018000", + "0x5", + "0x400680017fff7fff", + "0x90", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x5", + "0x480a7ffc7fff8000", + "0x480a7ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x482a7ffc7ffb8000", + "0x480a7ffc7fff8000", + "0x48127ffe7fff8000", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff7", + "0x208b7fff7fff7ffe" + ], + "debug_info": { + "file_contents": {}, + "instruction_locations": { + "0": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 0, + "offset": 0 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 29, + "end_line": 3, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 28, + "start_line": 3 + } + }, + "2": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 0, + "offset": 1 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 3, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 31, + "start_line": 3 + } + }, + "4": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 0, + "offset": 2 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 3, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 34, + "start_line": 3 + } + }, + "6": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 0, + "offset": 3 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 3, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 24, + "start_line": 3 + } + }, + "8": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 0 + }, + "reference_ids": { + "__main__.main.result": 0 + } + }, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 6, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 5, + "start_line": 6 + } + }, + "10": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 0 + }, + "reference_ids": { + "__main__.main.result": 0 + } + }, + "hints": [], + "inst": { + "end_col": 8, + "end_line": 7, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 5, + "start_line": 7 + } + }, + "11": { + "accessible_scopes": [ + "__main__", + "__main__.fib" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "__main__.fib.first_element": 1, + "__main__.fib.n": 3, + "__main__.fib.second_element": 2 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 11, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 5, + "start_line": 11 + } + }, + "13": { + "accessible_scopes": [ + "__main__", + "__main__.fib" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "__main__.fib.first_element": 1, + "__main__.fib.n": 3, + "__main__.fib.second_element": 2 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 10, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 12, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 22, + "start_line": 12 + }, + "While expanding the reference 'second_element' in:" + ], + "start_col": 25, + "start_line": 10 + } + }, + "14": { + "accessible_scopes": [ + "__main__", + "__main__.fib" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 1 + }, + "reference_ids": { + "__main__.fib.first_element": 1, + "__main__.fib.n": 3, + "__main__.fib.result": 4, + "__main__.fib.second_element": 2 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 10, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 13, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 13, + "start_line": 13 + }, + "While expanding the reference 'second_element' in:" + ], + "start_col": 25, + "start_line": 10 + } + }, + "15": { + "accessible_scopes": [ + "__main__", + "__main__.fib" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 2 + }, + "reference_ids": { + "__main__.fib.first_element": 1, + "__main__.fib.n": 3, + "__main__.fib.result": 4, + "__main__.fib.second_element": 2 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 13, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 5, + "start_line": 13 + } + }, + "16": { + "accessible_scopes": [ + "__main__", + "__main__.fib" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "__main__.fib.first_element": 1, + "__main__.fib.n": 3, + "__main__.fib.second_element": 2 + } + }, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 16, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 17, + "start_line": 16 + } + }, + "17": { + "accessible_scopes": [ + "__main__", + "__main__.fib" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 1 + }, + "reference_ids": { + "__main__.fib.first_element": 1, + "__main__.fib.n": 3, + "__main__.fib.second_element": 2, + "__main__.fib.y": 5 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 10, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 17, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 16, + "start_line": 17 + }, + "While expanding the reference 'second_element' in:" + ], + "start_col": 25, + "start_line": 10 + } + }, + "18": { + "accessible_scopes": [ + "__main__", + "__main__.fib" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 2 + }, + "reference_ids": { + "__main__.fib.first_element": 1, + "__main__.fib.n": 3, + "__main__.fib.second_element": 2, + "__main__.fib.y": 5 + } + }, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 16, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 17, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 32, + "start_line": 17 + }, + "While expanding the reference 'y' in:" + ], + "start_col": 13, + "start_line": 16 + } + }, + "19": { + "accessible_scopes": [ + "__main__", + "__main__.fib" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "__main__.fib.first_element": 1, + "__main__.fib.n": 3, + "__main__.fib.second_element": 2, + "__main__.fib.y": 5 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 17, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 35, + "start_line": 17 + } + }, + "21": { + "accessible_scopes": [ + "__main__", + "__main__.fib" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 4 + }, + "reference_ids": { + "__main__.fib.first_element": 1, + "__main__.fib.n": 3, + "__main__.fib.second_element": 2, + "__main__.fib.y": 5 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 17, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 12, + "start_line": 17 + } + }, + "23": { + "accessible_scopes": [ + "__main__", + "__main__.fib" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 3, + "offset": 0 + }, + "reference_ids": { + "__main__.fib.first_element": 1, + "__main__.fib.n": 3, + "__main__.fib.second_element": 2, + "__main__.fib.y": 5 + } + }, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 17, + "input_file": { + "filename": "cairo_programs/fibonacci.cairo" + }, + "start_col": 5, + "start_line": 17 + } + } + } + }, + "hints": {}, + "identifiers": { + "__main__.fib": { + "decorators": [], + "pc": 11, + "type": "function" + }, + "__main__.fib.Args": { + "full_name": "__main__.fib.Args", + "members": { + "first_element": { + "cairo_type": "felt", + "offset": 0 + }, + "n": { + "cairo_type": "felt", + "offset": 2 + }, + "second_element": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.fib.ImplicitArgs": { + "full_name": "__main__.fib.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.fib.Return": { + "cairo_type": "(res: felt)", + "type": "type_definition" + }, + "__main__.fib.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.fib.fib_body": { + "pc": 16, + "type": "label" + }, + "__main__.fib.first_element": { + "cairo_type": "felt", + "full_name": "__main__.fib.first_element", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 11, + "value": "[cast(fp + (-5), felt*)]" + } + ], + "type": "reference" + }, + "__main__.fib.n": { + "cairo_type": "felt", + "full_name": "__main__.fib.n", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 11, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "__main__.fib.result": { + "cairo_type": "felt", + "full_name": "__main__.fib.result", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 1 + }, + "pc": 14, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.fib.second_element": { + "cairo_type": "felt", + "full_name": "__main__.fib.second_element", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 11, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "__main__.fib.y": { + "cairo_type": "felt", + "full_name": "__main__.fib.y", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 1 + }, + "pc": 17, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.main": { + "decorators": [], + "pc": 0, + "type": "function" + }, + "__main__.main.Args": { + "full_name": "__main__.main.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.main.ImplicitArgs": { + "full_name": "__main__.main.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.main.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.main.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.main.result": { + "cairo_type": "felt", + "full_name": "__main__.main.result", + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 0 + }, + "pc": 8, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + } + }, + "main_scope": "__main__", + "prime": "0x800000000000011000000000000000000000000000000000000000000000001", + "reference_manager": { + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 0 + }, + "pc": 8, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 11, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 11, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 11, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 1 + }, + "pc": 14, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 1 + }, + "pc": 17, + "value": "[cast(ap + (-1), felt*)]" + } + ] + } +} diff --git a/examples/run_program.rs b/examples/run_program.rs new file mode 100644 index 0000000..3e375c9 --- /dev/null +++ b/examples/run_program.rs @@ -0,0 +1,136 @@ +use std::any::Any; +use std::collections::HashMap; +use std::error::Error; + +use cairo_vm::cairo_run::{cairo_run_program, CairoRunConfig}; +use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::{ + BuiltinHintProcessor, HintProcessorData, +}; +use cairo_vm::hint_processor::hint_processor_definition::{HintExtension, HintProcessorLogic}; +use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::types::layout_name::LayoutName; +use cairo_vm::types::program::Program; +use cairo_vm::vm::errors::cairo_run_errors::CairoRunError; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::runners::cairo_runner::{CairoRunner, ResourceTracker}; +use cairo_vm::vm::vm_core::VirtualMachine; +use cairo_vm::Felt252; +use starknet_types_core::felt::Felt; + +use cairo_bootloader::tasks::make_bootloader_tasks; +use cairo_bootloader::{ + insert_bootloader_input, load_bootloader, BootloaderConfig, BootloaderHintProcessor, + BootloaderInput, PackedOutput, SimpleBootloaderInput, TaskSpec, +}; + +struct ExampleHintProcessor { + bootloader_hint_processor: BootloaderHintProcessor, + builtin_hint_processor: BuiltinHintProcessor, +} + +impl ExampleHintProcessor { + fn new() -> Self { + Self { + bootloader_hint_processor: BootloaderHintProcessor {}, + builtin_hint_processor: BuiltinHintProcessor::new_empty(), + } + } +} + +impl HintProcessorLogic for ExampleHintProcessor { + fn execute_hint( + &mut self, + _vm: &mut VirtualMachine, + _exec_scopes: &mut ExecutionScopes, + hint_data: &Box, + _constants: &HashMap, + ) -> Result<(), HintError> { + // This method will never be called, but must be defined according to `HintProcessorLogic`. + + let hint_data = hint_data.downcast_ref::().unwrap(); + let hint_code = &hint_data.code; + Err(HintError::UnknownHint(hint_code.clone().into_boxed_str())) + } + + fn execute_hint_extensive( + &mut self, + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + hint_data: &Box, + constants: &HashMap, + ) -> Result { + // Cascade through the internal hint processors until we find the hint implementation. + + match self.bootloader_hint_processor.execute_hint_extensive( + vm, + exec_scopes, + hint_data, + constants, + ) { + Err(HintError::UnknownHint(_)) => {} + result => { + return result; + } + } + + self.builtin_hint_processor + .execute_hint_extensive(vm, exec_scopes, hint_data, constants) + } +} + +impl ResourceTracker for ExampleHintProcessor {} + +fn cairo_run_bootloader_in_proof_mode( + bootloader_program: &Program, + tasks: Vec, +) -> Result { + let mut hint_processor = ExampleHintProcessor::new(); + + let cairo_run_config = CairoRunConfig { + entrypoint: "main", + trace_enabled: false, + relocate_mem: false, + layout: LayoutName::starknet_with_keccak, + proof_mode: true, + secure_run: None, + disable_trace_padding: false, + allow_missing_builtins: None, + }; + + let n_tasks = tasks.len(); + let bootloader_input = BootloaderInput { + simple_bootloader_input: SimpleBootloaderInput { + fact_topologies_path: None, + single_page: false, + tasks, + }, + bootloader_config: BootloaderConfig { + simple_bootloader_program_hash: Felt252::from(0), + supported_cairo_verifier_program_hashes: vec![], + }, + packed_outputs: vec![PackedOutput::Plain(vec![]); n_tasks], + }; + + // Note: the method used to set the bootloader input depends on + // https://github.com/lambdaclass/cairo-vm/pull/1772 and may change depending on review. + let mut exec_scopes = ExecutionScopes::new(); + insert_bootloader_input(&mut exec_scopes, bootloader_input); + + cairo_run_program( + &bootloader_program, + &cairo_run_config, + &mut hint_processor, + Some(exec_scopes), + ) +} + +fn main() -> Result<(), Box> { + let bootloader_program = load_bootloader()?; + let fibonacci_program = include_bytes!("fibonacci.json"); + + let tasks = make_bootloader_tasks(&[fibonacci_program], &[])?; + + let _runner = cairo_run_bootloader_in_proof_mode(&bootloader_program, tasks)?; + + Ok(()) +} diff --git a/resources/bootloader-0.13.1.json b/resources/bootloader-0.13.1.json new file mode 100644 index 0000000..517ab31 --- /dev/null +++ b/resources/bootloader-0.13.1.json @@ -0,0 +1,35810 @@ +{ + "attributes": [], + "builtins": [ + "output", + "pedersen", + "range_check", + "ecdsa", + "bitwise", + "ec_op", + "keccak", + "poseidon", + "range_check96" + ], + "compiler_version": "0.13.0", + "data": [ + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x482480017ffe8000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffff", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x4", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0x404b800080008000", + "0x400380007ff98001", + "0x400380007ffa8002", + "0x20780017fff8000", + "0x4", + "0x10780017fff7fff", + "0x4", + "0x400380007ffb8001", + "0x400380007ffc8002", + "0x482680017ff98000", + "0x1", + "0x482680017ffa8000", + "0x1", + "0x482a80007ffb8000", + "0x482a80007ffc8000", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffea", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe1", + "0x484680017ffb8000", + "0xa", + "0x482480017fff8000", + "0xc", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffc7fff8000", + "0x48307ffc7ff98000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffdc", + "0x402a7ffc7ffd7fff", + "0x40b7ffd7fff7fff", + "0x208b7fff7fff7ffe", + "0x48297ffb80007ffc", + "0x48487ffd80007fff", + "0x400280007ffa7fff", + "0x482680017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x4", + "0x480a7ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff97fff8000", + "0x480280007ffa8000", + "0x480280007ffb8000", + "0x480280007ffc8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff3", + "0x482680017ffa8000", + "0x1", + "0x482680017ffb8000", + "0x1", + "0x482680017ffc8000", + "0x1", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffef", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480a7ffd7fff8000", + "0x480a7ffb7fff8000", + "0x40780017fff7fff", + "0x1", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x3a", + "0x480080007ffd8000", + "0x48307fff7ff98000", + "0x400080007ffc7fff", + "0x480080017ffb8000", + "0x48307fff7ff88000", + "0x400080017ffa7fff", + "0x400080027ffa7ff8", + "0x480080037ffa8000", + "0x480080027ff88000", + "0x48307fff7ffe8000", + "0x400080067ff77fff", + "0x480080047ff78000", + "0x480080037ff58000", + "0x48307fff7ffe8000", + "0x400080077ff47fff", + "0x480080057ff48000", + "0x400080087ff37fff", + "0x480080097ff38000", + "0x480080047ff18000", + "0x48307fff7ffe8000", + "0x4000800c7ff07fff", + "0x4800800a7ff08000", + "0x480080057fee8000", + "0x48307fff7ffe8000", + "0x4000800d7fed7fff", + "0x4800800b7fed8000", + "0x4000800e7fec7fff", + "0x4800800f7fec8000", + "0x480080067fea8000", + "0x48307fff7ffe8000", + "0x400080127fe97fff", + "0x480080107fe98000", + "0x480080077fe78000", + "0x48307fff7ffe8000", + "0x400080137fe67fff", + "0x480080117fe68000", + "0x400080147fe57fff", + "0x480080157fe58000", + "0x480080087fe38000", + "0x48307fff7ffe8000", + "0x400080187fe27fff", + "0x480080167fe28000", + "0x480080097fe08000", + "0x48307fff7ffe8000", + "0x400080197fdf7fff", + "0x480080177fdf8000", + "0x4000801a7fde7fff", + "0x4800801b7fde8000", + "0x4800801c7fdd8000", + "0x4800801d7fdc8000", + "0x482480017fda8000", + "0xa", + "0x482480017fda8000", + "0x1e", + "0x10780017fff7fff", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc5", + "0x40780017fff7fff", + "0x1", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x12", + "0x480080007ffc8000", + "0x48307fff7ff88000", + "0x400080007ffb7fff", + "0x480080017ffa8000", + "0x48307fff7ff78000", + "0x400080017ff97fff", + "0x400080027ff97ff7", + "0x480080037ff98000", + "0x480080047ff88000", + "0x480080057ff78000", + "0x482480017ff58000", + "0x2", + "0x482480017ff58000", + "0x6", + "0x10780017fff7fff", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffaf", + "0x482a7ffc7ffd8000", + "0x48307ffb80007fff", + "0x20680017fff7fff", + "0xb", + "0x482480017ff78000", + "0x1", + "0x400080007ffa7fff", + "0x400080017ffa7ff7", + "0x400080027ffa7ff8", + "0x482480017ffa8000", + "0x6", + "0x480080037ff98000", + "0x208b7fff7fff7ffe", + "0x400680017fff7fff", + "0x1", + "0x480080007ffa8000", + "0x48307fff7ff68000", + "0x400080007ff97fff", + "0x482480017ff68000", + "0x1", + "0x400080017ff87fff", + "0x400080027ff87ff6", + "0x482480017ff88000", + "0x6", + "0x480080037ff78000", + "0x208b7fff7fff7ffe", + "0x480280007ffd8000", + "0x48327fff7ffd8000", + "0x480a7ffc7fff8000", + "0x480080007ffe8000", + "0x48007fff7ffd8000", + "0x480080007ffd7fff", + "0x400080017ffc7ffd", + "0x482480017ffb8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x482480017ffb8000", + "0x3", + "0x480080027ffa8000", + "0x40287ffd7ffc7ffd", + "0x20680017fff7ffc", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff8", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x20680017fff7fff", + "0xc", + "0x480a7ffb7fff8000", + "0x480280007ffc8000", + "0x482680017ffc8000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff73", + "0x480a7ffa7fff8000", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1a", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff18", + "0x40137ffe7fff8000", + "0x400380007ff98002", + "0x480680017fff8000", + "0x0", + "0x4002800180017fff", + "0x480280017ff98000", + "0x480280077ff98000", + "0x480a80017fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffde", + "0x4002800180027fff", + "0x4027800180018003", + "0x4", + "0x4003800380018004", + "0x482a800480038000", + "0x4802800280018000", + "0x40317fff7ffe8005", + "0x4027800180028006", + "0x2", + "0x40137ffb7fff8007", + "0x400380027ff98008", + "0x400380037ff98009", + "0x400380047ff9800a", + "0x400380057ff9800b", + "0x400380067ff9800c", + "0x40137ffc7fff800d", + "0x400380087ff9800e", + "0x480a7ffb7fff8000", + "0x4826800180008000", + "0x6", + "0x480680017fff8000", + "0x9", + "0x480a80037fff8000", + "0x480a80047fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff13", + "0x1088800580018000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffef1", + "0x402a8004800f7fff", + "0x480a7ffb7fff8000", + "0x4826800180008000", + "0x10", + "0x480a80037fff8000", + "0x480a800f7fff8000", + "0x480680017fff8000", + "0x9", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffeec", + "0x402a800380047fff", + "0x480a7ffa7fff8000", + "0x4826800180008000", + "0x6", + "0x4826800180008000", + "0x10", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x9", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff11", + "0x402b800280198010", + "0x4003800080028019", + "0x4826800180008000", + "0x10", + "0x48127ffe7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1d", + "0x402780017ff58001", + "0x1", + "0x400b7ff67fff8002", + "0x400b80007fff8003", + "0x400b7ff87fff8004", + "0x400b7ff97fff8005", + "0x400b7ffa7fff8006", + "0x400b7ffb7fff8007", + "0x400b7ffc7fff8008", + "0x400b7ffd7fff8009", + "0x400780017fff800a", + "0x6f7574707574", + "0x400780017fff800b", + "0x706564657273656e", + "0x400780017fff800c", + "0x72616e67655f636865636b", + "0x400780017fff800d", + "0x6563647361", + "0x400780017fff800e", + "0x62697477697365", + "0x400780017fff800f", + "0x65635f6f70", + "0x400780017fff8010", + "0x6b656363616b", + "0x400780017fff8011", + "0x706f736569646f6e", + "0x400780017fff8012", + "0x72616e67655f636865636b3936", + "0x400780017fff8013", + "0x1", + "0x400780017fff8014", + "0x3", + "0x400780017fff8015", + "0x1", + "0x400780017fff8016", + "0x2", + "0x400780017fff8017", + "0x5", + "0x400780017fff8018", + "0x7", + "0x400780017fff8019", + "0x10", + "0x400780017fff801a", + "0x6", + "0x400780017fff801b", + "0x1", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffea3", + "0x482480017ffe8000", + "0x1", + "0x480a7ff77fff8000", + "0x482480017ffc8000", + "0xa", + "0x482480017ffb8000", + "0x13", + "0x480280007ff58000", + "0x1104800180018000", + "0x24", + "0x400a80007fff7fff", + "0x40137ffe7fff801c", + "0x48028002801c8000", + "0x48307ffe80007fff", + "0x480680017fff8000", + "0x40", + "0x1104800180018000", + "0xc", + "0x48028000801c8000", + "0x48028001801c8000", + "0x48028002801c8000", + "0x48028003801c8000", + "0x48028004801c8000", + "0x48028005801c8000", + "0x48028006801c8000", + "0x48028007801c8000", + "0x48028008801c8000", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x5", + "0x400780017fff7ffc", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x48307fff7fff8000", + "0x48317fff80007ffc", + "0x40507fff7fff7fff", + "0x48127ffd7fff8000", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff4", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x5", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x48127ffb7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff50", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffef", + "0x208b7fff7fff7ffe", + "0x400380007ffc7ffd", + "0x482680017ffc8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x48297ffc80007ffd", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffb", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff6", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff6", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480a7ff97fff8000", + "0x480a80007fff8000", + "0x482680017ffc8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff2", + "0x484a80007ffb8000", + "0x48327fff7ffa8000", + "0x400180007fff7ffd", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x208b7fff7fff7ffe", + "0x400380007ffb7ffc", + "0x400380017ffb7ffd", + "0x482680017ffb8000", + "0x3", + "0x480280027ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe38", + "0x400780017fff8000", + "0x0", + "0x400780017fff8001", + "0x0", + "0x48127ffe7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x480a7ffa7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480280007ffb8000", + "0x1104800180018000", + "0x10", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe28", + "0x40137ffd7fff8000", + "0x480280017ffb8000", + "0x40297ffd7fff8001", + "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffde", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffc", + "0x5", + "0x480a7ffa7fff8000", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x482680017ffc8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x40337fff7ffb8000", + "0x480a7ffb7fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffd7fff8000", + "0x48317ffd80008000", + "0x400080007ffd7ffe", + "0x480080007ffc8000", + "0x400080017ffc7fff", + "0x482480017ffb8000", + "0x1", + "0x482480017ffb8000", + "0x3", + "0x480080027ffa8000", + "0x20680017fff7ffb", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff8", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc8", + "0x480a7ffb7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffcc", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffda", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x3", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480080007fff8000", + "0x400080007ffd7fff", + "0x482480017ffd8001", + "0x1", + "0x482480017ffd8001", + "0x1", + "0xa0680017fff7ffe", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffb", + "0x402a7ffc7ffd7fff", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xb", + "0x480a80007fff8000", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff0a", + "0x40137ff97fff8001", + "0x40137ffa7fff8002", + "0x40137ffb7fff8003", + "0x40137ffc7fff8004", + "0x40137ffd7fff8005", + "0x40137ffe7fff8006", + "0x40137fff7fff8007", + "0x40137ff77fff8008", + "0x480a7ff57fff8000", + "0x48127ff77fff8000", + "0x480a80097fff8000", + "0x1104800180018000", + "0x45", + "0x40137ffe7fff800a", + "0x482480017ffe8000", + "0x1", + "0x48127ffe7fff8000", + "0x480a80067fff8000", + "0x480a80017fff8000", + "0x480680017fff8000", + "0x0", + "0x4826800180008000", + "0x1", + "0x480a80097fff8000", + "0x4802800080008000", + "0x1104800180018000", + "0xe", + "0x40137fff7fff8008", + "0x40028000800a7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffb7fff8000", + "0x480a80027fff8000", + "0x480a80037fff8000", + "0x480a80047fff8000", + "0x480a80057fff8000", + "0x48127ff57fff8000", + "0x480a80077fff8000", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x9", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x0", + "0x40780017fff7fff", + "0x1", + "0x20680017fff7fff", + "0xd", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x23", + "0x10780017fff7fff", + "0xb", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x46", + "0x480a7ffc7fff8000", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffdb", + "0x208b7fff7fff7ffe", + "0x480280007ffd8000", + "0x400280007ffb7fff", + "0x480a7ffc7fff8000", + "0x480280027ffd8000", + "0x480280017ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff85", + "0x400280017ffb7fff", + "0x482680017ffb8000", + "0x2", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x2", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x4", + "0x480a7ff97fff8000", + "0x480a80017fff8000", + "0x480a80007fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffdc0", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff5", + "0x480680017fff8000", + "0x4", + "0x400080007ffe7fff", + "0x480a7ffa7fff8000", + "0x480280027ffd8000", + "0x480680017fff8000", + "0x1", + "0x480280017ffd8000", + "0x480080017ffa8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff1a", + "0x480280007ffd8000", + "0x400080007fdd7fff", + "0x400080017fdd7fd9", + "0x402580017fdd8002", + "0x2", + "0x400b80007fff8003", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x48127fd67fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x4802800080008000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffa4", + "0x402a800180037fff", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480a80027fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffcc", + "0x40137ffe7fff8000", + "0x480080007fff8000", + "0x400280007ff77fff", + "0x480080017ffe8000", + "0x400280017ff77fff", + "0x480080007ffd8000", + "0x402580017fff8001", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffff", + "0x482680017ff78000", + "0x2", + "0x480a80007fff8000", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff46", + "0x482680017ff78000", + "0x2", + "0x482880017fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x482680017ffb8000", + "0x1", + "0x482a800180008000", + "0x208b7fff7fff7ffe" + ], + "debug_info": { + "file_contents": {}, + "instruction_locations": { + "0": { + "accessible_scopes": [ + "starkware.cairo.lang.compiler.lib.registers", + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 0, + "offset": 0 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 7, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" + }, + "start_col": 5, + "start_line": 7 + } + }, + "1": { + "accessible_scopes": [ + "starkware.cairo.lang.compiler.lib.registers", + "starkware.cairo.lang.compiler.lib.registers.get_ap" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 0 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" + }, + "start_col": 28, + "start_line": 16 + } + }, + "3": { + "accessible_scopes": [ + "starkware.cairo.lang.compiler.lib.registers", + "starkware.cairo.lang.compiler.lib.registers.get_ap" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val": 0, + "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val": 1 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" + }, + "start_col": 20, + "start_line": 17 + } + }, + "5": { + "accessible_scopes": [ + "starkware.cairo.lang.compiler.lib.registers", + "starkware.cairo.lang.compiler.lib.registers.get_ap" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val": 0, + "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val": 1 + } + }, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" + }, + "start_col": 5, + "start_line": 17 + } + }, + "6": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 30, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 30 + } + }, + "8": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 40, + "start_line": 32 + }, + "While expanding the reference 'selected_encodings' in:" + ], + "start_col": 5, + "start_line": 21 + } + }, + "9": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 9, + "start_line": 32 + } + }, + "10": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 35 + } + }, + "12": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 46, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 38 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 53, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 48 + } + }, + "13": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 50, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 50 + } + }, + "14": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 51, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 51 + } + }, + "15": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 53 + } + }, + "17": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 53 + } + }, + "19": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 56, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 9, + "start_line": 56 + } + }, + "20": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 58, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 9, + "start_line": 58 + } + }, + "21": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 23, + "start_line": 65 + } + }, + "23": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 18, + "start_line": 66 + } + }, + "25": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 28, + "start_line": 67 + } + }, + "26": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 68, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 23, + "start_line": 68 + } + }, + "27": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 69, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 20, + "start_line": 69 + } + }, + "29": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 12, + "start_line": 64 + } + }, + "31": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 3, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 64 + } + }, + "32": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 23, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 17, + "start_line": 23 + } + }, + "34": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [ + { + "location": { + "end_col": 75, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 5, + "start_line": 26 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 77, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 25, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 23, + "start_line": 31 + }, + "While expanding the reference 'selected_ptrs' in:" + ], + "start_col": 40, + "start_line": 25 + }, + "While expanding the reference 'total_func_memory' in:" + ], + "start_col": 29, + "start_line": 21 + }, + "While expanding the reference 'inner_func_memory' in:" + ], + "start_col": 29, + "start_line": 19 + } + }, + "36": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 25, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 23, + "start_line": 31 + }, + "While expanding the reference 'selected_ptrs' in:" + ], + "start_col": 40, + "start_line": 25 + }, + "While expanding the reference 'total_func_memory' in:" + ], + "start_col": 29, + "start_line": 21 + } + }, + "38": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 7, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 23, + "start_line": 28 + }, + "While expanding the reference 'all_encodings' in:" + ], + "start_col": 5, + "start_line": 7 + } + }, + "39": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 8, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 18, + "start_line": 29 + }, + "While expanding the reference 'all_ptrs' in:" + ], + "start_col": 5, + "start_line": 8 + } + }, + "40": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 10, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 30, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 28, + "start_line": 30 + }, + "While expanding the reference 'selected_encodings' in:" + ], + "start_col": 5, + "start_line": 10 + } + }, + "41": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 25, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 23, + "start_line": 31 + }, + "While expanding the reference 'selected_ptrs' in:" + ], + "start_col": 25, + "start_line": 25 + } + }, + "42": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 20, + "start_line": 32 + }, + "While expanding the reference 'n_all_builtins' in:" + ], + "start_col": 5, + "start_line": 9 + } + }, + "43": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 33, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 21, + "start_line": 27 + } + }, + "45": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 5, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [ + { + "location": { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 5, + "start_line": 34 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 80, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 5, + "start_line": 36 + } + }, + "46": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 5, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 38, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 5, + "start_line": 38 + } + }, + "47": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 6, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 8, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 5, + "start_line": 39 + } + }, + "48": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 25 + } + }, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 20, + "start_line": 16 + } + }, + "49": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 25 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 23, + "start_line": 17 + } + }, + "50": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": 27, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 25 + } + }, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 18 + } + }, + "51": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": 27, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 28 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 11, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 20, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 20 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 23, + "start_line": 11 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 27, + "start_line": 19 + } + }, + "53": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": 27, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 28 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 20, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 20 + } + }, + "54": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 40, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 40 + } + }, + "56": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 9, + "start_line": 41 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 37 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 37 + } + }, + "57": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 9, + "start_line": 41 + } + }, + "58": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 11, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 44 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 23, + "start_line": 11 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 37 + } + }, + "59": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 26, + "start_line": 45 + } + }, + "60": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 46, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 25, + "start_line": 46 + } + }, + "61": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 31, + "start_line": 47 + } + }, + "62": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "64": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 + } + }, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 51, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 27, + "start_line": 51 + } + }, + "66": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 52, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 26, + "start_line": 52 + } + }, + "68": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 + } + }, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 32, + "start_line": 53 + } + }, + "70": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 20, + "start_line": 54 + } + }, + "72": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 13 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 12, + "start_line": 50 + } + }, + "74": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 9, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 35 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 50 + } + }, + "75": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 45, + "start_line": 34 + } + }, + "77": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38 + } + }, + "hints": [], + "inst": { + "end_col": 52, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 51, + "start_line": 34 + } + }, + "79": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38 + } + }, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 57, + "start_line": 34 + } + }, + "81": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 24, + "start_line": 35 + }, + "While expanding the reference 'elements' in:" + ], + "start_col": 66, + "start_line": 28 + } + }, + "82": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 28, + "start_line": 36 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 25, + "start_line": 28 + } + }, + "83": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [ + { + "location": { + "end_col": 59, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 39 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 59, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 39 + } + }, + "85": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 39 + } + }, + "87": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 39 + } + }, + "89": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 41 + } + }, + "90": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 41 + } + }, + "91": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 42, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 40 + } + }, + "92": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 41 + } + }, + "93": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 41 + } + }, + "94": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 42, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 40 + } + }, + "95": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 42, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 40 + } + }, + "96": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 47 + } + }, + "97": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 47 + } + }, + "98": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 47 + } + }, + "99": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 13 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 46 + } + }, + "100": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 13 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 47 + } + }, + "101": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 14 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 47 + } + }, + "102": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 15 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 47 + } + }, + "103": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 16 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 46 + } + }, + "104": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 16 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 70, + "start_line": 47 + } + }, + "105": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 17 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 46 + } + }, + "106": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 17 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 53 + } + }, + "107": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 18 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 53 + } + }, + "108": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 19 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 53 + } + }, + "109": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 20 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 52 + } + }, + "110": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 20 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 53 + } + }, + "111": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 21 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 53 + } + }, + "112": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 22 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 53 + } + }, + "113": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 23 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 52 + } + }, + "114": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 23 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 70, + "start_line": 53 + } + }, + "115": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 24 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 52 + } + }, + "116": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 24 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 59 + } + }, + "117": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 25 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 59 + } + }, + "118": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 26 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 59 + } + }, + "119": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 27 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 60, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 58 + } + }, + "120": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 27 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 59 + } + }, + "121": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 59 + } + }, + "122": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 59 + } + }, + "123": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 30 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 60, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 58 + } + }, + "124": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 30 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 70, + "start_line": 59 + } + }, + "125": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 31 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 60, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 58 + } + }, + "126": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 31 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 65 + } + }, + "127": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 32 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 65 + } + }, + "128": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 33 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 65 + } + }, + "129": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 34 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 64 + } + }, + "130": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 34 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 65 + } + }, + "131": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 35 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 65 + } + }, + "132": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 36 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 65 + } + }, + "133": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 37 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 64 + } + }, + "134": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 37 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 70, + "start_line": 65 + } + }, + "135": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 38 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 64 + } + }, + "136": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 38 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 84 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 70 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "137": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 39 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 84 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 70 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "138": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 40 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 84 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 70 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "139": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 41 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 86 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 29, + "start_line": 71 + } + }, + "141": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 42 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 87, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 86 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 68, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 32, + "start_line": 72 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 28, + "start_line": 68 + } + }, + "143": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 43 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 87, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 88, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 86 + } + }, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 73, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 73 + } + }, + "145": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [ + { + "location": { + "end_col": 58, + "end_line": 76, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 76 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 58, + "end_line": 76, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 76 + } + }, + "147": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 76, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 76 + } + }, + "149": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 76, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 76 + } + }, + "151": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 78, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 78 + } + }, + "152": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 78, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 78 + } + }, + "153": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 77 + } + }, + "154": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 78, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 78 + } + }, + "155": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 78, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 78 + } + }, + "156": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 77 + } + }, + "157": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 77 + } + }, + "158": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 94 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 80, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 83, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 83 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 80 + } + }, + "159": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 94 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 80, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 83, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 83 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 80 + } + }, + "160": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 13 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 94 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 80, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 83, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 83 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 80 + } + }, + "161": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 14 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 96 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 84, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 29, + "start_line": 84 + } + }, + "163": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 15 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 97, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 96 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 81, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 85, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 32, + "start_line": 85 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 28, + "start_line": 81 + } + }, + "165": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 16 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 97, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 98, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 96 + } + }, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 86, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 86 + } + }, + "167": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 89, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 17, + "start_line": 89 + }, + "While expanding the reference 'elements_end' in:" + ], + "start_col": 25, + "start_line": 29 + } + }, + "168": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 89, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 17, + "start_line": 89 + } + }, + "169": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 91, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 91 + } + }, + "171": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 93, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 61, + "start_line": 93 + } + }, + "173": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 101, + "end_line": 93, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 93 + } + }, + "174": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 101, + "end_line": 93, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 93 + } + }, + "175": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 101, + "end_line": 93, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 93 + } + }, + "176": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 106, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 105, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 95, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 96, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 96 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 25, + "start_line": 28 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 28, + "start_line": 95 + } + }, + "178": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 106, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 105, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 94, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 96, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 21, + "start_line": 96 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 19, + "start_line": 94 + } + }, + "179": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 106, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 105, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 96, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 96 + } + }, + "180": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 99, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 99 + } + }, + "182": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 23, + "start_line": 102 + } + }, + "183": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 12, + "start_line": 102 + } + }, + "184": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 103, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 101 + } + }, + "185": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 39, + "start_line": 102 + } + }, + "187": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 103, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 101 + } + }, + "188": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 103, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 101 + } + }, + "189": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 111, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 110, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 105, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 106 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 25, + "start_line": 28 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 24, + "start_line": 105 + } + }, + "191": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 13 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 111, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 110, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 104, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 17, + "start_line": 106 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 15, + "start_line": 104 + } + }, + "192": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 14 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 111, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 110, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 106 + } + }, + "193": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 15, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 27, + "start_line": 15 + } + }, + "194": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 + } + }, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 28, + "start_line": 16 + } + }, + "195": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 8, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 41, + "start_line": 19 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 17, + "start_line": 8 + } + }, + "196": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 + } + }, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 60, + "start_line": 19 + } + }, + "197": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116 + } + }, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 24, + "start_line": 26 + } + }, + "198": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 30, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 5, + "start_line": 30 + } + }, + "199": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 5, + "start_line": 31 + } + }, + "200": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 18, + "start_line": 35 + } + }, + "202": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 18, + "start_line": 36 + } + }, + "204": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 18, + "start_line": 37 + } + }, + "205": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119, + "starkware.cairo.common.hash_chain.hash_chain.next_frame": 121 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 5, + "start_line": 41 + } + }, + "206": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119, + "starkware.cairo.common.hash_chain.hash_chain.next_frame": 121 + } + }, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 42, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 5, + "start_line": 42 + } + }, + "208": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 122, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119, + "starkware.cairo.common.hash_chain.hash_chain.next_frame": 121 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 46, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 5, + "start_line": 46 + } + }, + "209": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 48 + } + }, + "211": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 48 + } + }, + "213": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 49, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 54, + "start_line": 49 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 55, + "start_line": 45 + } + }, + "214": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 50, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 15, + "start_line": 50 + } + }, + "215": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 50, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 46, + "start_line": 50 + } + }, + "217": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 51, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 49 + } + }, + "219": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 14, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 52, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 52 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 27, + "start_line": 45 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 27, + "start_line": 45 + } + }, + "220": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 14, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 49, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 52, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 52 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 55, + "start_line": 45 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 54, + "start_line": 49 + } + }, + "221": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 14, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 49, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 52, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 52 + }, + "While expanding the reference 'hash' in:" + ], + "start_col": 14, + "start_line": 49 + } + }, + "222": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 14, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 52, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 52 + } + }, + "223": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 42, + "start_line": 54 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 27, + "start_line": 45 + } + }, + "224": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 46, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 65, + "start_line": 54 + }, + "While expanding the reference 'program_data_ptr' in:" + ], + "start_col": 5, + "start_line": 46 + } + }, + "225": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 54 + } + }, + "227": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 15, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 55 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 27, + "start_line": 45 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 54 + } + }, + "228": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 15, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 55 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 55, + "start_line": 45 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 55, + "start_line": 45 + } + }, + "229": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 15, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 55 + }, + "While expanding the reference 'hash' in:" + ], + "start_col": 14, + "start_line": 54 + } + }, + "230": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 15, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 55 + } + }, + "231": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 69, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "233": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 26 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 29, + "start_line": 72 + } + }, + "235": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 137, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 10, + "start_line": 72 + } + }, + "236": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 68, + "end_line": 76, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 76 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 50, + "end_line": 80, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 80 + } + }, + "237": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 91, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 83 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 66, + "end_line": 94, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 48, + "start_line": 94 + } + }, + "239": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 94, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 94 + } + }, + "240": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 97, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 100 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 27, + "start_line": 45 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 24, + "start_line": 97 + } + }, + "241": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 30 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 98, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 100 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 55, + "start_line": 45 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 24, + "start_line": 98 + } + }, + "242": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 31 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 75, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 101, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 30, + "start_line": 101 + }, + "While expanding the reference 'program_data_ptr' in:" + ], + "start_col": 11, + "start_line": 75 + } + }, + "243": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 32 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 94, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 101, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 61, + "start_line": 101 + }, + "While expanding the reference 'use_poseidon' in:" + ], + "start_col": 76, + "start_line": 66 + } + }, + "244": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 33 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 100 + } + }, + "246": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 106 + } + }, + "247": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 114, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 107 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 62, + "end_line": 117, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 117 + } + }, + "249": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 118, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 118 + } + }, + "250": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 119, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 31, + "start_line": 119 + } + }, + "251": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 123, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 120 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 55, + "end_line": 124, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 28, + "start_line": 124 + } + }, + "252": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 126, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 126 + } + }, + "253": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "255": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "256": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "257": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "258": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "259": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "260": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "261": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "262": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "263": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 144, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 23, + "start_line": 144 + }, + "While expanding the reference 'builtin_encodings' in:" + ], + "start_col": 5, + "start_line": 66 + } + }, + "264": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 130, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 145, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 19, + "start_line": 145 + }, + "While expanding the reference 'pre_execution_builtin_ptrs' in:" + ], + "start_col": 11, + "start_line": 130 + } + }, + "266": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 146, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 24, + "start_line": 146 + } + }, + "268": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 117, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 147, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 28, + "start_line": 147 + }, + "While expanding the reference 'builtin_list' in:" + ], + "start_col": 11, + "start_line": 117 + } + }, + "269": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 118, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 29, + "start_line": 148 + }, + "While expanding the reference 'n_builtins' in:" + ], + "start_col": 11, + "start_line": 118 + } + }, + "270": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 149, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 143 + } + }, + "272": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 18, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 185, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 152 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 33, + "end_line": 188, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 188 + } + }, + "273": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 194, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 191 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 28, + "end_line": 198, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 20, + "start_line": 198 + } + }, + "275": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 199, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 199 + } + }, + "276": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 217, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 206 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 36, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 23, + "start_line": 219 + }, + "While expanding the reference 'builtin_encodings' in:" + ], + "start_col": 5, + "start_line": 66 + } + }, + "277": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 205, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 220, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 19, + "start_line": 220 + }, + "While expanding the reference 'return_builtin_ptrs' in:" + ], + "start_col": 11, + "start_line": 205 + } + }, + "279": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 117, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 221, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 28, + "start_line": 221 + }, + "While expanding the reference 'builtin_list' in:" + ], + "start_col": 11, + "start_line": 117 + } + }, + "280": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 29, + "end_line": 199, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 222, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 23, + "start_line": 222 + }, + "While expanding the reference 'used_builtins_addr' in:" + ], + "start_col": 11, + "start_line": 199 + } + }, + "281": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 223, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 20, + "start_line": 223 + } + }, + "283": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 224, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 31, + "start_line": 218 + } + }, + "285": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [ + { + "location": { + "end_col": 26, + "end_line": 225, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 225 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 83, + "end_line": 229, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 229 + } + }, + "286": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 232, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 39, + "start_line": 232 + }, + "While expanding the reference 'self_range_check_ptr' in:" + ], + "start_col": 47, + "start_line": 65 + } + }, + "287": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 130, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 233, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 28, + "start_line": 233 + }, + "While expanding the reference 'pre_execution_builtin_ptrs' in:" + ], + "start_col": 11, + "start_line": 130 + } + }, + "289": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 205, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 234, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 27, + "start_line": 234 + }, + "While expanding the reference 'return_builtin_ptrs' in:" + ], + "start_col": 11, + "start_line": 205 + } + }, + "291": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 235, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 32, + "start_line": 235 + }, + "While expanding the reference 'builtin_instance_sizes' in:" + ], + "start_col": 38, + "start_line": 66 + } + }, + "292": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 236, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 20, + "start_line": 236 + } + }, + "294": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 237, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 232 + } + }, + "296": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 241, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 241 + } + }, + "297": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 242, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 242 + } + }, + "298": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 161, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 256, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 244 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 30, + "end_line": 205, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 258, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 259, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 259 + }, + "While trying to retrieve the implicit argument 'builtin_ptrs' in:" + ], + "start_col": 19, + "start_line": 65 + }, + "While expanding the reference 'builtin_ptrs' in:" + ], + "start_col": 25, + "start_line": 258 + }, + "While expanding the reference 'return_builtin_ptrs' in:" + ], + "start_col": 11, + "start_line": 205 + } + }, + "300": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 161, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 232, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 67, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 259, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 259 + }, + "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" + ], + "start_col": 47, + "start_line": 65 + }, + "While expanding the reference 'self_range_check_ptr' in:" + ], + "start_col": 39, + "start_line": 232 + } + }, + "301": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 161, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 259, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 259 + } + }, + "302": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 162, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 24, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 24 + } + }, + "304": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 38, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 27 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "306": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "307": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "308": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "309": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "310": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "311": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "312": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "313": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "314": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "316": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "318": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "320": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "322": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "324": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "326": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "328": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "330": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "332": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "334": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "336": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "338": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "340": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "342": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "344": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "346": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "348": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "350": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 82, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 23, + "start_line": 82 + } + }, + "352": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 31 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [ + { + "location": { + "end_col": 48, + "end_line": 84, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 84 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 30, + "end_line": 44, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 85, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 88 + }, + "While trying to retrieve the implicit argument 'builtin_ptrs' in:" + ], + "start_col": 20, + "start_line": 153 + }, + "While expanding the reference 'builtin_ptrs' in:" + ], + "start_col": 25, + "start_line": 85 + }, + "While expanding the reference 'builtin_ptrs_before' in:" + ], + "start_col": 11, + "start_line": 44 + } + }, + "354": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 32 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 86, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 88 + }, + "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" + ], + "start_col": 48, + "start_line": 153 + }, + "While expanding the reference 'self_range_check_ptr' in:" + ], + "start_col": 32, + "start_line": 86 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 16 + } + }, + "355": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 33 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 57, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 89, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 32, + "start_line": 89 + }, + "While expanding the reference 'builtin_encodings' in:" + ], + "start_col": 11, + "start_line": 57 + } + }, + "357": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 34 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 69, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 90, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 37, + "start_line": 90 + }, + "While expanding the reference 'builtin_instance_sizes' in:" + ], + "start_col": 11, + "start_line": 69 + } + }, + "359": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 35 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 40, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 91, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 21, + "start_line": 91 + }, + "While expanding the reference 'n_tasks' in:" + ], + "start_col": 19, + "start_line": 40 + } + }, + "360": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 36 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 88 + } + }, + "362": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 180, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 96, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 96 + } + }, + "363": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 180, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 99, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 99 + } + }, + "364": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 119, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 120, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 29, + "start_line": 120 + }, + "While expanding the reference 'additional_range_checks' in:" + ], + "start_col": 35, + "start_line": 119 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 27, + "start_line": 102 + } + }, + "365": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 119, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 120, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 29, + "start_line": 120 + }, + "While expanding the reference 'additional_range_checks' in:" + ], + "start_col": 35, + "start_line": 119 + } + }, + "366": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 120, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 61, + "start_line": 120 + } + }, + "368": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 120, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 120 + } + }, + "370": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 100, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 14, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 14 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 100 + } + }, + "371": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 101, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 15, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 15 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 24, + "start_line": 101 + } + }, + "372": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 16 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 27, + "start_line": 102 + } + }, + "373": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 103, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'ecdsa_ptr' in:" + ], + "start_col": 5, + "start_line": 17 + }, + "While expanding the reference 'ecdsa_ptr' in:" + ], + "start_col": 21, + "start_line": 103 + } + }, + "374": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 104, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'bitwise_ptr' in:" + ], + "start_col": 5, + "start_line": 18 + }, + "While expanding the reference 'bitwise_ptr' in:" + ], + "start_col": 23, + "start_line": 104 + } + }, + "375": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 105, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'ec_op_ptr' in:" + ], + "start_col": 5, + "start_line": 19 + }, + "While expanding the reference 'ec_op_ptr' in:" + ], + "start_col": 21, + "start_line": 105 + } + }, + "376": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 20, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'keccak_ptr' in:" + ], + "start_col": 5, + "start_line": 20 + }, + "While expanding the reference 'keccak_ptr' in:" + ], + "start_col": 22, + "start_line": 106 + } + }, + "377": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 107, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 21 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 24, + "start_line": 107 + } + }, + "378": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 108, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 22, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'range_check96_ptr' in:" + ], + "start_col": 5, + "start_line": 22 + }, + "While expanding the reference 'range_check96_ptr' in:" + ], + "start_col": 29, + "start_line": 108 + } + }, + "379": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + } + }, + "380": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 128, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 128 + } + }, + "382": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 129, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 129 + } + }, + "384": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 130, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 130 + } + }, + "385": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 + } + }, + "hints": [ + { + "location": { + "end_col": 50, + "end_line": 133, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 133 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 50, + "end_line": 133, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 133 + } + }, + "387": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 134, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 26, + "start_line": 134 + } + }, + "388": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 134, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 19, + "start_line": 134 + } + }, + "389": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 136, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 136 + } + }, + "390": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 133, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 36, + "start_line": 137 + }, + "While expanding the reference 'num_div2' in:" + ], + "start_col": 13, + "start_line": 133 + } + }, + "391": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 53, + "start_line": 137 + } + }, + "393": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 12, + "start_line": 137 + } + }, + "395": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 26, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 137 + } + }, + "396": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 156, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 156 + } + }, + "398": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 157, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 157 + }, + "While trying to retrieve the implicit argument 'builtin_ptrs' in:" + ], + "start_col": 20, + "start_line": 153 + }, + "While expanding the reference 'builtin_ptrs' in:" + ], + "start_col": 20, + "start_line": 153 + } + }, + "399": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + }, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 157, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 157 + }, + "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" + ], + "start_col": 48, + "start_line": 153 + }, + "While expanding the reference 'self_range_check_ptr' in:" + ], + "start_col": 48, + "start_line": 153 + } + }, + "400": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 157, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 157 + } + }, + "401": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 166, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 160 + }, + "n_prefix_newlines": 1 + }, + { + "location": { + "end_col": 71, + "end_line": 167, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 167 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 71, + "end_line": 167, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 167 + } + }, + "403": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 169 + }, + "While trying to retrieve the implicit argument 'builtin_ptrs' in:" + ], + "start_col": 19, + "start_line": 65 + }, + "While expanding the reference 'builtin_ptrs' in:" + ], + "start_col": 20, + "start_line": 153 + } + }, + "404": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 67, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 169 + }, + "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" + ], + "start_col": 47, + "start_line": 65 + }, + "While expanding the reference 'self_range_check_ptr' in:" + ], + "start_col": 48, + "start_line": 153 + } + }, + "405": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 154, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 27, + "start_line": 170 + }, + "While expanding the reference 'builtin_encodings' in:" + ], + "start_col": 5, + "start_line": 154 + } + }, + "406": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 154, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 32, + "start_line": 171 + }, + "While expanding the reference 'builtin_instance_sizes' in:" + ], + "start_col": 38, + "start_line": 154 + } + }, + "407": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 167, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 22, + "start_line": 172 + }, + "While expanding the reference 'use_poseidon' in:" + ], + "start_col": 13, + "start_line": 167 + } + }, + "408": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 169 + } + }, + "410": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 28, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 154, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 176, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 27, + "start_line": 176 + }, + "While expanding the reference 'builtin_encodings' in:" + ], + "start_col": 5, + "start_line": 154 + } + }, + "411": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 28, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 154, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 32, + "start_line": 177 + }, + "While expanding the reference 'builtin_instance_sizes' in:" + ], + "start_col": 38, + "start_line": 154 + } + }, + "412": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 28, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 178, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 17, + "start_line": 178 + } + }, + "414": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 28, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 179, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 12, + "start_line": 175 + } + }, + "416": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 29, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 207, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 208, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 179, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 175 + } + }, + "417": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 30, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn.a": 209, + "starkware.cairo.common.math.assert_nn.range_check_ptr": 210 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 46, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 42 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 26, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 47 + } + }, + "418": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 30, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn.a": 209, + "starkware.cairo.common.math.assert_nn.range_check_ptr": 211 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 49, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 49 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 41 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 27, + "start_line": 48 + } + }, + "420": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 30, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn.a": 209, + "starkware.cairo.common.math.assert_nn.range_check_ptr": 211 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 49, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 49 + } + }, + "421": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 31, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_le.a": 212, + "starkware.cairo.common.math.assert_le.b": 213, + "starkware.cairo.common.math.assert_le.range_check_ptr": 214 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 54 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 41 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 53 + } + }, + "422": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 31, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_le.a": 212, + "starkware.cairo.common.math.assert_le.b": 213, + "starkware.cairo.common.math.assert_le.range_check_ptr": 214 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 15, + "start_line": 54 + } + }, + "423": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 31, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_le.a": 212, + "starkware.cairo.common.math.assert_le.b": 213, + "starkware.cairo.common.math.assert_le.range_check_ptr": 214 + } + }, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 54 + } + }, + "425": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 31, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_le.a": 212, + "starkware.cairo.common.math.assert_le.b": 213, + "starkware.cairo.common.math.assert_le.range_check_ptr": 215 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 55 + } + }, + "426": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 218 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 71 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 41 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 70 + } + }, + "427": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 218 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 15, + "start_line": 71 + }, + "While expanding the reference 'a' in:" + ], + "start_col": 36, + "start_line": 70 + } + }, + "428": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 218 + } + }, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 71 + } + }, + "430": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 219 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 15, + "start_line": 72 + }, + "While expanding the reference 'a' in:" + ], + "start_col": 36, + "start_line": 70 + } + }, + "431": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 219 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 18, + "start_line": 72 + }, + "While expanding the reference 'b' in:" + ], + "start_col": 39, + "start_line": 70 + } + }, + "432": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 219 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 72 + } + }, + "434": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 14 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 220 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 73, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 73 + } + }, + "435": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 27, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 27 + } + }, + "437": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 29 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 34, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 61 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 70 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 26 + } + }, + "438": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + }, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 20, + "start_line": 61 + }, + "While expanding the reference 'index' in:" + ], + "start_col": 11, + "start_line": 28 + } + }, + "439": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 29, + "start_line": 61 + } + }, + "441": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 61 + } + }, + "443": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 20 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 35, + "start_line": 62 + } + }, + "444": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 21 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.__temp49": 228, + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 23, + "start_line": 62 + } + }, + "445": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 22 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.__temp49": 228, + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_ptr": 229, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 63, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 63 + } + }, + "446": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 22 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.__temp49": 228, + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_ptr": 229, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 64, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 64 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 26 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 61 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 70 + } + }, + "447": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 23 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.__temp49": 228, + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_ptr": 229, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 64, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 21, + "start_line": 64 + }, + "While expanding the reference 'elm_ptr' in:" + ], + "start_col": 13, + "start_line": 62 + } + }, + "448": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 24 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.__temp49": 228, + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_ptr": 229, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 64, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 64 + } + }, + "449": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 34, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash.hash2.hash_ptr": 232, + "starkware.cairo.common.hash.hash2.x": 230, + "starkware.cairo.common.hash.hash2.y": 231 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 14, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 14 + } + }, + "450": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 34, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash.hash2.hash_ptr": 232, + "starkware.cairo.common.hash.hash2.x": 230, + "starkware.cairo.common.hash.hash2.y": 231 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 15, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 15 + } + }, + "451": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 34, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash.hash2.hash_ptr": 234, + "starkware.cairo.common.hash.hash2.result": 233, + "starkware.cairo.common.hash.hash2.x": 230, + "starkware.cairo.common.hash.hash2.y": 231 + } + }, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 18 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 12, + "start_line": 13 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 20, + "start_line": 17 + } + }, + "453": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 34, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.hash.hash2.hash_ptr": 234, + "starkware.cairo.common.hash.hash2.result": 233, + "starkware.cairo.common.hash.hash2.x": 230, + "starkware.cairo.common.hash.hash2.y": 231 + } + }, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "start_col": 20, + "start_line": 18 + }, + "While expanding the reference 'result' in:" + ], + "start_col": 18, + "start_line": 16 + } + }, + "454": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 34, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash.hash2.hash_ptr": 234, + "starkware.cairo.common.hash.hash2.result": 233, + "starkware.cairo.common.hash.hash2.x": 230, + "starkware.cairo.common.hash.hash2.y": 231 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 18 + } + }, + "455": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 0 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 18 + } + }, + "457": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 2 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 23, + "start_line": 19 + } + }, + "459": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_init.__fp__": 235, + "starkware.cairo.common.hash_state.hash_init.hash_state": 236 + } + }, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 21 + } + }, + "461": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_init.__fp__": 235, + "starkware.cairo.common.hash_state.hash_init.hash_state": 236 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 22, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 22 + } + }, + "463": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_init.__fp__": 235, + "starkware.cairo.common.hash_state.hash_init.hash_state": 236 + } + }, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 20, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 23, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 29, + "start_line": 23 + }, + "While expanding the reference 'hash_state' in:" + ], + "start_col": 11, + "start_line": 20 + }, + "While expanding the reference '__fp__' in:" + ], + "start_col": 10, + "start_line": 19 + } + }, + "464": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_init.__fp__": 235, + "starkware.cairo.common.hash_state.hash_init.hash_state": 236 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 23, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 23 + } + }, + "465": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 32 + } + }, + "467": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 82, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 33 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 28, + "start_line": 82 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 29 + } + }, + "468": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 30, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 34 + }, + "While expanding the reference 'data_ptr' in:" + ], + "start_col": 33, + "start_line": 30 + } + }, + "469": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 30, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 40, + "start_line": 34 + }, + "While expanding the reference 'data_length' in:" + ], + "start_col": 50, + "start_line": 30 + } + }, + "470": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 93, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 66, + "start_line": 34 + } + }, + "471": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 33 + } + }, + "473": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 23, + "start_line": 36 + } + }, + "475": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 38, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 38 + } + }, + "476": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 37, + "start_line": 39 + } + }, + "477": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.__temp50": 245, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 39 + } + }, + "478": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.__temp50": 245, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 82, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 40, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 40 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 29 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 33 + }, + "While trying to update the implicit return value 'hash_ptr' in:" + ], + "start_col": 28, + "start_line": 82 + } + }, + "479": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.__temp50": 245, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 40, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 33, + "start_line": 40 + }, + "While expanding the reference 'new_hash_state' in:" + ], + "start_col": 11, + "start_line": 37 + }, + "While expanding the reference '__fp__' in:" + ], + "start_col": 10, + "start_line": 36 + } + }, + "480": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.__temp50": 245, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 40, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 40 + } + }, + "481": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 38, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 + } + }, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 71 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 12, + "start_line": 13 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 20, + "start_line": 70 + } + }, + "482": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 38, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 26, + "start_line": 71 + } + }, + "483": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 38, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 + } + }, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 57, + "start_line": 71 + } + }, + "484": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 38, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 + } + }, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 71 + } + }, + "486": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 38, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_finalize.hash": 249, + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 248, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 72 + } + }, + "487": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 85, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 85 + } + }, + "489": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 82, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 82, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 86, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 9, + "start_line": 86 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 28, + "start_line": 82 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 28, + "start_line": 82 + } + }, + "490": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 83, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 86, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 22, + "start_line": 86 + }, + "While expanding the reference 'initial_hash' in:" + ], + "start_col": 41, + "start_line": 83 + } + }, + "491": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 86, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 9, + "start_line": 86 + } + }, + "492": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 90, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 90 + } + }, + "494": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 91, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 34, + "start_line": 91 + } + }, + "496": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 91, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 91 + } + }, + "497": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 100, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 100 + } + }, + "498": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 101, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 101 + } + }, + "499": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 102 + } + }, + "500": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 107, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 36, + "start_line": 107 + } + }, + "501": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 110, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 110 + } + }, + "502": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 37, + "start_line": 111 + } + }, + "503": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 111 + } + }, + "504": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 115, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 115 + } + }, + "506": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 116, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 116 + } + }, + "508": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 117, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 117 + } + }, + "509": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 120, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 120 + } + }, + "511": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.final_locals": 261, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 262, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 125, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 125 + } + }, + "512": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 40, + "start_line": 137 + } + }, + "514": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 136, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 28, + "start_line": 138 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 29 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 17, + "start_line": 136 + } + }, + "515": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 139, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 24, + "start_line": 139 + }, + "While expanding the reference 'hash_state_ptr' in:" + ], + "start_col": 10, + "start_line": 137 + } + }, + "516": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 52, + "end_line": 136, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 139, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 49, + "start_line": 139 + }, + "While expanding the reference 'data' in:" + ], + "start_col": 41, + "start_line": 136 + } + }, + "517": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 136, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 139, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 67, + "start_line": 139 + }, + "While expanding the reference 'length' in:" + ], + "start_col": 54, + "start_line": 136 + } + }, + "518": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 28, + "start_line": 138 + } + }, + "520": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 41, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 267, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 268, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 141, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 12, + "start_line": 141 + } + }, + "522": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 41, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 269, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 268, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 141, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 141 + } + }, + "523": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 8, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 8 + } + }, + "525": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 9, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 9, + "start_line": 9 + } + }, + "526": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [ + { + "location": { + "end_col": 41, + "end_line": 12, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 12 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 23, + "end_line": 2, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 13, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 35, + "start_line": 13 + }, + "While expanding the reference 'dst' in:" + ], + "start_col": 13, + "start_line": 2 + } + }, + "527": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 2, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 13, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 44, + "start_line": 13 + }, + "While expanding the reference 'src' in:" + ], + "start_col": 25, + "start_line": 2 + } + }, + "528": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 26, + "start_line": 17 + } + }, + "529": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 17 + } + }, + "530": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 22, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 22 + } + }, + "532": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 23, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 23 + } + }, + "534": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 27, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 24 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 44, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 29 + } + }, + "536": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 31 + } + }, + "537": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [ + { + "location": { + "end_col": 26, + "end_line": 33, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 33 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 15, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 34 + } + }, + "538": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 41 + } + }, + "540": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 11 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + }, + "n_prefix_newlines": 1 + }, + { + "location": { + "end_col": 53, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 61 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 41, + "end_line": 43, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 77, + "end_line": 57, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 38, + "start_line": 62 + }, + "While expanding the reference 'simple_bootloader_output_ptr' in:" + ], + "start_col": 47, + "start_line": 57 + }, + "While expanding the reference 'simple_bootloader_output_start' in:" + ], + "start_col": 11, + "start_line": 43 + } + }, + "541": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 12 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 15, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 15 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 32 + } + }, + "542": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 13 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 33, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 16 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 33 + } + }, + "543": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 14 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'ecdsa_ptr' in:" + ], + "start_col": 5, + "start_line": 17 + }, + "While expanding the reference 'ecdsa_ptr' in:" + ], + "start_col": 5, + "start_line": 34 + } + }, + "544": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 15 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'bitwise_ptr' in:" + ], + "start_col": 5, + "start_line": 18 + }, + "While expanding the reference 'bitwise_ptr' in:" + ], + "start_col": 5, + "start_line": 35 + } + }, + "545": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 16 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'ec_op_ptr' in:" + ], + "start_col": 5, + "start_line": 19 + }, + "While expanding the reference 'ec_op_ptr' in:" + ], + "start_col": 5, + "start_line": 36 + } + }, + "546": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 17 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 20, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'keccak_ptr' in:" + ], + "start_col": 5, + "start_line": 20 + }, + "While expanding the reference 'keccak_ptr' in:" + ], + "start_col": 5, + "start_line": 37 + } + }, + "547": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 18 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 38, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 21 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 38 + } + }, + "548": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 19 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 22, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'range_check96_ptr' in:" + ], + "start_col": 5, + "start_line": 22 + }, + "While expanding the reference 'range_check96_ptr' in:" + ], + "start_col": 5, + "start_line": 39 + } + }, + "549": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 20 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + } + }, + "551": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 293, + "__main__.main.ec_op_ptr": 294, + "__main__.main.ecdsa_ptr": 292, + "__main__.main.keccak_ptr": 295, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 291, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 63, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 63 + } + }, + "552": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 293, + "__main__.main.ec_op_ptr": 294, + "__main__.main.ecdsa_ptr": 292, + "__main__.main.keccak_ptr": 295, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 64, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 64 + } + }, + "553": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 293, + "__main__.main.ec_op_ptr": 294, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 295, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 65 + } + }, + "554": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 294, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 295, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 66 + } + }, + "555": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 295, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 67 + } + }, + "556": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 68, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 68 + } + }, + "557": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 69, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "558": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 70 + } + }, + "559": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 75, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 72 + }, + "n_prefix_newlines": 1 + }, + { + "location": { + "end_col": 7, + "end_line": 89, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 78 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 22, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 92 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 34, + "start_line": 219 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 31 + } + }, + "560": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 1 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 15, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 92 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 53, + "start_line": 219 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 62 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 15 + } + }, + "561": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 2 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 77, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 51, + "start_line": 92 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 11, + "start_line": 77 + } + }, + "562": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 3 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 92 + } + }, + "564": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 307, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 95, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 95 + } + }, + "565": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [ + { + "location": { + "end_col": 40, + "end_line": 97, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 97 + }, + "n_prefix_newlines": 0 + }, + { + "location": { + "end_col": 59, + "end_line": 107, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 107 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 36, + "end_line": 96, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 96 + } + }, + "567": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 1 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 92 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 53, + "start_line": 219 + } + }, + "568": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 2 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 68, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 11, + "start_line": 68 + } + }, + "569": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 3 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 63, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 11, + "start_line": 63 + } + }, + "570": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 4 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 31, + "start_line": 106 + } + }, + "572": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 5 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 103, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 109, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 37, + "start_line": 109 + }, + "While expanding the reference 'simple_bootloader_output_ptr' in:" + ], + "start_col": 40, + "start_line": 103 + } + }, + "574": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 6 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 77, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 110, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 31, + "start_line": 110 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 11, + "start_line": 77 + } + }, + "575": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 7 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 52, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 71, + "end_line": 110, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 61, + "start_line": 110 + }, + "While expanding the reference 'n_subtasks' in:" + ], + "start_col": 22, + "start_line": 102 + } + }, + "576": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 8 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + } + }, + "578": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 116, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 116 + } + }, + "579": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 119, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 119 + } + }, + "580": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 149, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 121 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 31 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 9, + "start_line": 109 + }, + "While trying to update the implicit return value 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + } + }, + "581": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 1 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 32 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 9, + "start_line": 109 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + } + }, + "582": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 2 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 33, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 33 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 9, + "start_line": 109 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + } + }, + "583": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 3 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 64, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'ecdsa_ptr' in:" + ], + "start_col": 5, + "start_line": 34 + }, + "While expanding the reference 'ecdsa_ptr' in:" + ], + "start_col": 11, + "start_line": 64 + } + }, + "584": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 4 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'bitwise_ptr' in:" + ], + "start_col": 5, + "start_line": 35 + }, + "While expanding the reference 'bitwise_ptr' in:" + ], + "start_col": 11, + "start_line": 65 + } + }, + "585": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 5 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'ec_op_ptr' in:" + ], + "start_col": 5, + "start_line": 36 + }, + "While expanding the reference 'ec_op_ptr' in:" + ], + "start_col": 11, + "start_line": 66 + } + }, + "586": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 6 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'keccak_ptr' in:" + ], + "start_col": 5, + "start_line": 37 + }, + "While expanding the reference 'keccak_ptr' in:" + ], + "start_col": 11, + "start_line": 67 + } + }, + "587": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 7 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 38, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 38 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 9, + "start_line": 109 + }, + "While trying to update the implicit return value 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + } + }, + "588": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 8 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 69, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'range_check96_ptr' in:" + ], + "start_col": 5, + "start_line": 39 + }, + "While expanding the reference 'range_check96_ptr' in:" + ], + "start_col": 11, + "start_line": 69 + } + }, + "589": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 9 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + } + }, + "590": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 176, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 176 + } + }, + "592": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + } + }, + "593": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + } + }, + "594": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 2 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + } + }, + "595": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 3 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + } + }, + "596": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 4 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + } + }, + "597": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 5 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 174, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 174, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'subtasks_output' in:" + ], + "start_col": 5, + "start_line": 174 + }, + "While expanding the reference 'subtasks_output' in:" + ], + "start_col": 5, + "start_line": 174 + } + }, + "598": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 6 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + } + }, + "599": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 180, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 180 + } + }, + "601": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 189, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 182 + }, + "n_prefix_newlines": 1 + }, + { + "location": { + "end_col": 7, + "end_line": 196, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 191 + }, + "n_prefix_newlines": 1 + }, + { + "location": { + "end_col": 66, + "end_line": 198, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 198 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 66, + "end_line": 198, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 198 + } + }, + "603": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 198, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 198 + } + }, + "605": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [ + { + "location": { + "end_col": 70, + "end_line": 203, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 203 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 260, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 260 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + } + }, + "606": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 2 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 261, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 261 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + } + }, + "607": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 3 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 262, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 262 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + } + }, + "608": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 4 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 263, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 263 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + } + }, + "609": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 5 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 264, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 264 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + } + }, + "610": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 6 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 174, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 204, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 50, + "start_line": 204 + }, + "While expanding the reference 'subtasks_output' in:" + ], + "start_col": 5, + "start_line": 174 + } + }, + "611": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 7 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 175, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 205, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 31, + "start_line": 205 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 3, + "start_line": 175 + } + }, + "612": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 8 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + } + }, + "614": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 48, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 335, + "__main__.parse_tasks.output_ptr": 331, + "__main__.parse_tasks.pedersen_ptr": 332, + "__main__.parse_tasks.poseidon_ptr": 333, + "__main__.parse_tasks.range_check_ptr": 334, + "__main__.parse_tasks.subtasks_output": 336 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 198, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 198 + } + }, + "616": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 329, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 329 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + } + }, + "617": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 2 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 330, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 330 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + } + }, + "618": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 3 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 331, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 331 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + } + }, + "619": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 4 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 332, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 332 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + } + }, + "620": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 5 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 333, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 333 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + } + }, + "621": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 6 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 174, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 61, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 46, + "start_line": 200 + }, + "While expanding the reference 'subtasks_output' in:" + ], + "start_col": 5, + "start_line": 174 + } + }, + "622": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 7 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 175, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 98, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 81, + "start_line": 200 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 3, + "start_line": 175 + } + }, + "623": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 8 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + } + }, + "625": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 50, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 347, + "__main__.parse_tasks.output_ptr": 343, + "__main__.parse_tasks.pedersen_ptr": 344, + "__main__.parse_tasks.poseidon_ptr": 345, + "__main__.parse_tasks.range_check_ptr": 346, + "__main__.parse_tasks.subtasks_output": 348 + } + }, + "hints": [ + { + "location": { + "end_col": 26, + "end_line": 209, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 209 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 39, + "end_line": 175, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 212, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 42, + "start_line": 212 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 3, + "start_line": 175 + } + }, + "626": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 50, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 347, + "__main__.parse_tasks.output_ptr": 343, + "__main__.parse_tasks.pedersen_ptr": 344, + "__main__.parse_tasks.poseidon_ptr": 345, + "__main__.parse_tasks.range_check_ptr": 346, + "__main__.parse_tasks.subtasks_output": 348 + } + }, + "hints": [], + "inst": { + "end_col": 86, + "end_line": 212, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 72, + "start_line": 212 + } + }, + "628": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 50, + "offset": 2 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 347, + "__main__.parse_tasks.output_ptr": 343, + "__main__.parse_tasks.pedersen_ptr": 344, + "__main__.parse_tasks.poseidon_ptr": 345, + "__main__.parse_tasks.range_check_ptr": 346, + "__main__.parse_tasks.subtasks_output": 348 + } + }, + "hints": [], + "inst": { + "end_col": 87, + "end_line": 212, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 12, + "start_line": 212 + } + }, + "630": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 51, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 353, + "__main__.parse_tasks.output_ptr": 349, + "__main__.parse_tasks.pedersen_ptr": 350, + "__main__.parse_tasks.poseidon_ptr": 351, + "__main__.parse_tasks.range_check_ptr": 352, + "__main__.parse_tasks.subtasks_output": 354 + } + }, + "hints": [], + "inst": { + "end_col": 88, + "end_line": 212, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 212 + } + }, + "631": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 0 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 222, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 27, + "start_line": 222 + } + }, + "632": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 1 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 222, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 222 + } + }, + "633": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 1 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 225, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 64, + "start_line": 225 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 53, + "start_line": 219 + } + }, + "634": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 2 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 226, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 14, + "start_line": 226 + } + }, + "635": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 3 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 227, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 16, + "start_line": 227 + } + }, + "636": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 4 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 228, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 44, + "start_line": 225 + } + }, + "638": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 53, + "offset": 0 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 359, + "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 + } + }, + "hints": [], + "inst": { + "end_col": 62, + "end_line": 230, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 230 + } + }, + "639": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 53, + "offset": 0 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 361, + "__main__.serialize_bootloader_config.pedersen_ptr": 359, + "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 231, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 232, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 232 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 34, + "start_line": 219 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 231 + } + }, + "641": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 53, + "offset": 1 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 361, + "__main__.serialize_bootloader_config.pedersen_ptr": 359, + "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 + } + }, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 225, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 232, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 232 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 53, + "start_line": 219 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 64, + "start_line": 225 + } + }, + "642": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 53, + "offset": 2 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 361, + "__main__.serialize_bootloader_config.pedersen_ptr": 359, + "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 232, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 232 + } + }, + "643": { + "accessible_scopes": [ + "__main__", + "__main__.parse_task_header" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 54, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_task_header.task_header": 363, + "__main__.parse_task_header.task_output": 364 + } + }, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 242, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 240, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 243, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 243 + }, + "While trying to retrieve the implicit argument 'task_output' in:" + ], + "start_col": 24, + "start_line": 240 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 23, + "start_line": 242 + } + }, + "645": { + "accessible_scopes": [ + "__main__", + "__main__.parse_task_header" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 54, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_task_header.task_header": 363, + "__main__.parse_task_header.task_output": 364 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 241, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 243, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 25, + "start_line": 243 + }, + "While expanding the reference 'task_header' in:" + ], + "start_col": 23, + "start_line": 241 + } + }, + "646": { + "accessible_scopes": [ + "__main__", + "__main__.parse_task_header" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 54, + "offset": 2 + }, + "reference_ids": { + "__main__.parse_task_header.task_header": 363, + "__main__.parse_task_header.task_output": 364 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 243, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 243 + } + }, + "647": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 267, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 267 + } + }, + "649": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 4 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 276, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 272 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 35, + "end_line": 262, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 281, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 40, + "start_line": 279 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 25, + "start_line": 28 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 262 + } + }, + "650": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 5 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 271, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 280, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 11, + "start_line": 280 + }, + "While expanding the reference 'nested_subtasks_output_len' in:" + ], + "start_col": 11, + "start_line": 271 + } + }, + "651": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 6 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 270, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 280, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 48, + "start_line": 280 + }, + "While expanding the reference 'nested_subtasks_output' in:" + ], + "start_col": 11, + "start_line": 270 + } + }, + "652": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 7 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 281, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 40, + "start_line": 279 + } + }, + "654": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 265, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 240, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 284, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 44, + "start_line": 284 + }, + "While trying to retrieve the implicit argument 'task_output' in:" + ], + "start_col": 24, + "start_line": 240 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 5, + "start_line": 265 + } + }, + "655": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 1 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 284, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 44, + "start_line": 284 + } + }, + "657": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 5 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 285, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 31, + "start_line": 285 + } + }, + "659": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 6 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 285, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 285 + } + }, + "660": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 6 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 263, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 293, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 288 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 26 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 263 + } + }, + "661": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 7 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 289, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 19, + "start_line": 289 + } + }, + "662": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 8 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 290, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 18, + "start_line": 290 + } + }, + "664": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 9 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 291, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 16, + "start_line": 291 + } + }, + "665": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 10 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 292, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 13, + "start_line": 292 + } + }, + "666": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 11 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 293, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 288 + } + }, + "668": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 37 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 70, + "end_line": 297, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 22, + "start_line": 297 + } + }, + "669": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 299, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 296 + } + }, + "670": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 299, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 296 + } + }, + "671": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 300, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 300 + } + }, + "673": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 303, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 303 + } + }, + "674": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [ + { + "location": { + "end_col": 50, + "end_line": 306, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 306 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 22, + "end_line": 260, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 260 + } + }, + "675": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 39 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 261, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 261 + } + }, + "676": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 40 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 281, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 40, + "start_line": 279 + }, + "While trying to update the implicit return value 'poseidon_ptr' in:" + ], + "start_col": 25, + "start_line": 28 + } + }, + "677": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 41 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 293, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 288 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 26 + } + }, + "678": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 42 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 264, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 264 + } + }, + "679": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 43 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 305, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 308, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 37, + "start_line": 308 + }, + "While expanding the reference 'nested_subtasks_output' in:" + ], + "start_col": 34, + "start_line": 305 + } + }, + "681": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 44 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 266, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 309, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 31, + "start_line": 309 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 3, + "start_line": 266 + } + }, + "682": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 45 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 304, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 71, + "end_line": 309, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 61, + "start_line": 309 + }, + "While expanding the reference 'n_subtasks' in:" + ], + "start_col": 22, + "start_line": 304 + } + }, + "683": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 46 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + } + }, + "685": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 314, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 314 + } + }, + "686": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 260, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 260 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 9, + "start_line": 308 + }, + "While trying to update the implicit return value 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + } + }, + "687": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 1 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 261, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 261 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 9, + "start_line": 308 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + } + }, + "688": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 2 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 262, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 262 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 9, + "start_line": 308 + }, + "While trying to update the implicit return value 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + } + }, + "689": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 3 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 263, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 263 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 9, + "start_line": 308 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + } + }, + "690": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 4 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 264, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 264 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 9, + "start_line": 308 + }, + "While trying to update the implicit return value 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + } + }, + "691": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 5 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 300, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 265, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'task_output' in:" + ], + "start_col": 5, + "start_line": 265 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 11, + "start_line": 300 + } + }, + "692": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 6 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + } + }, + "693": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_output": 397 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 336, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 336 + } + }, + "695": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 2 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_output": 397 + } + }, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 334, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 240, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 339, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 44, + "start_line": 339 + }, + "While trying to retrieve the implicit argument 'task_output' in:" + ], + "start_col": 24, + "start_line": 240 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 5, + "start_line": 334 + } + }, + "696": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 3 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_output": 397 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 339, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 44, + "start_line": 339 + } + }, + "698": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 7 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 398 + } + }, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 340, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 340 + } + }, + "699": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 7 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 343, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 52, + "start_line": 343 + } + }, + "700": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 8 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 343, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 343 + } + }, + "701": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 8 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 343, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 52, + "start_line": 343 + } + }, + "702": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 9 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 343, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 343 + } + }, + "703": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 9 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 349, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 25, + "start_line": 349 + } + }, + "704": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 10 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 349, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 349 + } + }, + "706": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 10 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 346, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 350, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 16, + "start_line": 350 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 346 + } + }, + "708": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 11 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 340, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 350, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 32, + "start_line": 350 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 11, + "start_line": 340 + } + }, + "709": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 12 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 349, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 350, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 49, + "start_line": 350 + }, + "While expanding the reference 'output_size' in:" + ], + "start_col": 11, + "start_line": 349 + } + }, + "710": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 13 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 350, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 350 + } + }, + "712": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 346, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 353, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 329, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 329 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 353 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 346 + } + }, + "714": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 1 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 353, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 329, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 329 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 353 + } + }, + "715": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 2 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 330, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 330, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 330 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 330 + } + }, + "716": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 3 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 331, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 331, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 331 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 331 + } + }, + "717": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 4 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 332, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 332, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 332 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 332 + } + }, + "718": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 5 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 355, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 333, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 333 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 25, + "start_line": 355 + } + }, + "720": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 6 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 354, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 334, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'task_output' in:" + ], + "start_col": 5, + "start_line": 334 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 23, + "start_line": 354 + } + }, + "721": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 7 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + } + } + } + }, + "hints": { + "12": [ + { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "code": "# A builtin should be selected iff its encoding appears in the selected encodings list\n# and the list wasn't exhausted.\n# Note that testing inclusion by a single comparison is possible since the lists are sorted.\nids.select_builtin = int(\n n_selected_builtins > 0 and memory[ids.selected_encodings] == memory[ids.all_encodings])\nif ids.select_builtin:\n n_selected_builtins = n_selected_builtins - 1", + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + } + } + ], + "34": [ + { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "code": "vm_enter_scope({'n_selected_builtins': ids.n_selected_builtins})", + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + } + } + ], + "45": [ + { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "code": "vm_exit_scope()", + "flow_tracking_data": { + "ap_tracking": { + "group": 5, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + } + } + ], + "83": [ + { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "code": "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= 10)", + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + } + } + ], + "145": [ + { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "code": "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= 2)", + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + } + } + ], + "236": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "ids.program_data_ptr = program_data_base = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "237": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "from starkware.cairo.bootloaders.simple_bootloader.utils import load_program\n\n# Call load_program to load the program header and code to memory.\nprogram_address, program_data_size = load_program(\n task=task, memory=memory, program_header=ids.program_header,\n builtins_offset=ids.ProgramHeader.builtin_list)\nsegments.finalize(program_data_base.segment_index, program_data_size)", + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "247": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "# Validate hash.\nfrom starkware.cairo.bootloaders.hash_program import compute_program_hash_chain\n\nassert memory[ids.output_ptr + 1] == compute_program_hash_chain(\n program=task.get_program(),\n use_poseidon=bool(ids.use_poseidon)), 'Computed hash does not match input.'", + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "251": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "# Sanity check.\nassert ids.program_address == program_address", + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "272": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "from starkware.cairo.bootloaders.simple_bootloader.objects import (\n CairoPieTask,\n RunProgramTask,\n Task,\n)\nfrom starkware.cairo.bootloaders.simple_bootloader.utils import (\n load_cairo_pie,\n prepare_output_runner,\n)\n\nassert isinstance(task, Task)\nn_builtins = len(task.get_program().builtins)\nnew_task_locals = {}\nif isinstance(task, RunProgramTask):\n new_task_locals['program_input'] = task.program_input\n new_task_locals['WITH_BOOTLOADER'] = True\n\n vm_load_program(task.program, program_address)\nelif isinstance(task, CairoPieTask):\n ret_pc = ids.ret_pc_label.instruction_offset_ - ids.call_task.instruction_offset_ + pc\n load_cairo_pie(\n task=task.cairo_pie, memory=memory, segments=segments,\n program_address=program_address, execution_segment_address= ap - n_builtins,\n builtin_runners=builtin_runners, ret_fp=fp, ret_pc=ret_pc)\nelse:\n raise NotImplementedError(f'Unexpected task type: {type(task).__name__}.')\n\noutput_runner_data = prepare_output_runner(\n task=task,\n output_builtin=output_builtin,\n output_ptr=ids.pre_execution_builtin_ptrs.output)\nvm_enter_scope(new_task_locals)", + "flow_tracking_data": { + "ap_tracking": { + "group": 18, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "273": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "vm_exit_scope()\n# Note that bootloader_input will only be available in the next hint.", + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "276": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "from starkware.cairo.bootloaders.simple_bootloader.utils import write_return_builtins\n\n# Fill the values of all builtin pointers after executing the task.\nbuiltins = task.get_program().builtins\nwrite_return_builtins(\n memory=memory, return_builtins_addr=ids.return_builtin_ptrs.address_,\n used_builtins=builtins, used_builtins_addr=ids.used_builtins_addr,\n pre_execution_builtins_addr=ids.pre_execution_builtin_ptrs.address_, task=task)\n\nvm_enter_scope({'n_selected_builtins': n_builtins})", + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + } + } + ], + "285": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "vm_exit_scope()", + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + } + } + ], + "298": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "from starkware.cairo.bootloaders.simple_bootloader.utils import get_task_fact_topology\n\n# Add the fact topology of the current task to 'fact_topologies'.\noutput_start = ids.pre_execution_builtin_ptrs.output\noutput_end = ids.return_builtin_ptrs.output\nfact_topologies.append(get_task_fact_topology(\n output_size=output_end - output_start,\n task=task,\n output_builtin=output_builtin,\n output_runner_data=output_runner_data,\n))", + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + } + } + ], + "304": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "code": "n_tasks = len(simple_bootloader_input.tasks)\nmemory[ids.output_ptr] = n_tasks\n\n# Task range checks are located right after simple bootloader validation range checks, and\n# this is validated later in this function.\nids.task_range_check_ptr = ids.range_check_ptr + ids.BuiltinData.SIZE * n_tasks\n\n# A list of fact_toplogies that instruct how to generate the fact from the program output\n# for each task.\nfact_topologies = []", + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 162, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + } + } + ], + "352": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "code": "tasks = simple_bootloader_input.tasks", + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 31 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + } + } + ], + "385": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "code": "memory[ap] = to_felt_or_relocatable(ids.num // 2)", + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 + } + } + } + ], + "401": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "code": "from starkware.cairo.bootloaders.simple_bootloader.objects import Task\n\n# Pass current task to execute_task.\ntask_id = len(simple_bootloader_input.tasks) - ids.n_tasks\ntask = simple_bootloader_input.tasks[task_id].load_task()", + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + } + }, + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "code": "memory[ap] = to_felt_or_relocatable(1 if task.use_poseidon else 0)", + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + } + } + ], + "417": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "code": "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'", + "flow_tracking_data": { + "ap_tracking": { + "group": 30, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn.a": 209, + "starkware.cairo.common.math.assert_nn.range_check_ptr": 210 + } + } + } + ], + "437": [ + { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "code": "array_ptr = ids.array_ptr\nelm_size = ids.elm_size\nassert isinstance(elm_size, int) and elm_size > 0, \\\n f'Invalid value for elm_size. Got: {elm_size}.'\nkey = ids.key\n\nif '__find_element_index' in globals():\n ids.index = __find_element_index\n found_key = memory[array_ptr + elm_size * __find_element_index]\n assert found_key == key, \\\n f'Invalid index found in __find_element_index. index: {__find_element_index}, ' \\\n f'expected key {key}, found key: {found_key}.'\n # Delete __find_element_index to make sure it's not used for the next calls.\n del __find_element_index\nelse:\n n_elms = ids.n_elms\n assert isinstance(n_elms, int) and n_elms >= 0, \\\n f'Invalid value for n_elms. Got: {n_elms}.'\n if '__find_element_max_size' in globals():\n assert n_elms <= __find_element_max_size, \\\n f'find_element() can only be used with n_elms<={__find_element_max_size}. ' \\\n f'Got: n_elms={n_elms}.'\n\n for i in range(n_elms):\n if memory[array_ptr + elm_size * i] == key:\n ids.index = i\n break\n else:\n raise ValueError(f'Key {key} was not found.')", + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + } + } + ], + "526": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "vm_enter_scope({'n': ids.len})", + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + } + } + ], + "534": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "n -= 1\nids.continue_copying = 1 if n > 0 else 0", + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + } + } + ], + "537": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "vm_exit_scope()", + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + } + } + ], + "540": [ + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "from starkware.cairo.bootloaders.bootloader.objects import BootloaderInput\nbootloader_input = BootloaderInput.Schema().load(program_input)\n\nids.simple_bootloader_output_start = segments.add()\n\n# Change output builtin state to a different segment in preparation for calling the\n# simple bootloader.\noutput_builtin_state = output_builtin.get_state()\noutput_builtin.new_state(base=ids.simple_bootloader_output_start)", + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 11 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_start": 287 + } + } + }, + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "simple_bootloader_input = bootloader_input", + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 11 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + } + } + ], + "559": [ + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "# Restore the bootloader's output builtin state.\noutput_builtin.set_state(output_builtin_state)", + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + } + }, + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "from starkware.cairo.bootloaders.bootloader.objects import BootloaderConfig\nbootloader_config: BootloaderConfig = bootloader_input.bootloader_config\n\nids.bootloader_config = segments.gen_arg(\n [\n bootloader_config.simple_bootloader_program_hash,\n len(bootloader_config.supported_cairo_verifier_program_hashes),\n bootloader_config.supported_cairo_verifier_program_hashes,\n ],\n)", + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + } + } + ], + "565": [ + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "output_start = ids.output_ptr", + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + } + }, + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "packed_outputs = bootloader_input.packed_outputs", + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + } + } + ], + "580": [ + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "from typing import List\n\nfrom starkware.cairo.bootloaders.bootloader.utils import compute_fact_topologies\nfrom starkware.cairo.bootloaders.fact_topology import FactTopology\nfrom starkware.cairo.bootloaders.simple_bootloader.utils import (\n configure_fact_topologies,\n write_to_fact_topologies_file,\n)\n\n# Compute the fact topologies of the plain packed outputs based on packed_outputs and\n# fact_topologies of the inner tasks.\nplain_fact_topologies: List[FactTopology] = compute_fact_topologies(\n packed_outputs=packed_outputs, fact_topologies=fact_topologies,\n)\n\n# Configure the memory pages in the output builtin, based on plain_fact_topologies.\nconfigure_fact_topologies(\n fact_topologies=plain_fact_topologies, output_start=output_start,\n output_builtin=output_builtin,\n)\n\n# Dump fact topologies to a json file.\nif bootloader_input.fact_topologies_path is not None:\n write_to_fact_topologies_file(\n fact_topologies_path=bootloader_input.fact_topologies_path,\n fact_topologies=plain_fact_topologies,\n )", + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + } + } + ], + "601": [ + { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "code": "from starkware.cairo.bootloaders.bootloader.objects import PackedOutput\n\ntask_id = len(packed_outputs) - ids.n_subtasks\npacked_output: PackedOutput = packed_outputs[task_id]\n\nvm_enter_scope(new_scope_locals=dict(packed_output=packed_output))", + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + } + }, + { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "code": "from starkware.cairo.bootloaders.bootloader.objects import (\n CompositePackedOutput,\n PlainPackedOutput,\n)", + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + } + }, + { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "code": "memory[ap] = to_felt_or_relocatable(isinstance(packed_output, PlainPackedOutput))", + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + } + } + ], + "605": [ + { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "code": "assert isinstance(packed_output, CompositePackedOutput)", + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + } + } + ], + "625": [ + { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "code": "vm_exit_scope()", + "flow_tracking_data": { + "ap_tracking": { + "group": 50, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 347, + "__main__.parse_tasks.output_ptr": 343, + "__main__.parse_tasks.pedersen_ptr": 344, + "__main__.parse_tasks.poseidon_ptr": 345, + "__main__.parse_tasks.range_check_ptr": 346, + "__main__.parse_tasks.subtasks_output": 348 + } + } + } + ], + "649": [ + { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "code": "data = packed_output.elements_for_hash()\nids.nested_subtasks_output_len = len(data)\nids.nested_subtasks_output = segments.gen_arg(data)", + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 4 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + } + } + ], + "674": [ + { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "code": "packed_outputs = packed_output.subtasks", + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + } + } + ] + }, + "identifiers": { + "__main__.BootloaderConfig": { + "full_name": "__main__.BootloaderConfig", + "members": { + "simple_bootloader_program_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "supported_cairo_verifier_program_hashes": { + "cairo_type": "felt*", + "offset": 2 + }, + "supported_cairo_verifier_program_hashes_len": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.CairoVerifierOutput": { + "destination": "starkware.cairo.cairo_verifier.objects.CairoVerifierOutput", + "type": "alias" + }, + "__main__.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "__main__.PoseidonBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", + "type": "alias" + }, + "__main__.TaskOutputHeader": { + "full_name": "__main__.TaskOutputHeader", + "members": { + "program_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "size": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "__main__.find_element": { + "destination": "starkware.cairo.common.find_element.find_element", + "type": "alias" + }, + "__main__.hash_felts": { + "destination": "starkware.cairo.common.hash_state.hash_felts", + "type": "alias" + }, + "__main__.main": { + "decorators": [], + "pc": 538, + "type": "function" + }, + "__main__.main.Args": { + "full_name": "__main__.main.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.main.ImplicitArgs": { + "full_name": "__main__.main.ImplicitArgs", + "members": { + "bitwise_ptr": { + "cairo_type": "felt", + "offset": 4 + }, + "ec_op_ptr": { + "cairo_type": "felt", + "offset": 5 + }, + "ecdsa_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "keccak_ptr": { + "cairo_type": "felt", + "offset": 6 + }, + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 7 + }, + "range_check96_ptr": { + "cairo_type": "felt", + "offset": 8 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 9, + "type": "struct" + }, + "__main__.main.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.main.SIZEOF_LOCALS": { + "type": "const", + "value": 11 + }, + "__main__.main.bitwise_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.bitwise_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 554, + "value": "[cast(fp + 3, felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "full_name": "__main__.main.bootloader_config", + "references": [ + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 559, + "value": "[cast(fp + 9, __main__.BootloaderConfig**)]" + } + ], + "type": "reference" + }, + "__main__.main.ec_op_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.ec_op_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 555, + "value": "[cast(fp + 4, felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.ecdsa_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.ecdsa_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-8), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 553, + "value": "[cast(fp + 2, felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.keccak_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.keccak_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 556, + "value": "[cast(fp + 5, felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.n_subtasks": { + "cairo_type": "felt", + "full_name": "__main__.main.n_subtasks", + "references": [ + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast([fp], felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.n_total_tasks": { + "cairo_type": "felt", + "full_name": "__main__.main.n_total_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast(0, felt)" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-2), felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.output_n_total_tasks_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.main.output_n_total_tasks_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast(fp + 10, felt**)]" + } + ], + "type": "reference" + }, + "__main__.main.output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.main.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-11), felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 564, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast([ap + (-2)] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-6), felt**)]" + } + ], + "type": "reference" + }, + "__main__.main.parse_tasks_end": { + "cairo_type": "felt*", + "full_name": "__main__.main.parse_tasks_end", + "references": [ + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "__main__.main.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "__main__.main.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 564, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.main.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "__main__.main.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 557, + "value": "[cast(fp + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.main.range_check96_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.range_check96_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 558, + "value": "[cast(fp + 7, felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.range_check_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 552, + "value": "[cast(fp + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-3), felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.simple_bootloader_output_end": { + "cairo_type": "felt*", + "full_name": "__main__.main.simple_bootloader_output_end", + "references": [ + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 559, + "value": "[cast(fp + 8, felt**)]" + } + ], + "type": "reference" + }, + "__main__.main.simple_bootloader_output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.main.simple_bootloader_output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 11 + }, + "pc": 540, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast([fp] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "__main__.main.simple_bootloader_output_start": { + "cairo_type": "felt*", + "full_name": "__main__.main.simple_bootloader_output_start", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 11 + }, + "pc": 540, + "value": "[cast(fp, felt**)]" + } + ], + "type": "reference" + }, + "__main__.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__main__.parse_task_header": { + "decorators": [], + "pc": 643, + "type": "function" + }, + "__main__.parse_task_header.Args": { + "full_name": "__main__.parse_task_header.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.parse_task_header.ImplicitArgs": { + "full_name": "__main__.parse_task_header.ImplicitArgs", + "members": { + "task_output": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.parse_task_header.Return": { + "cairo_type": "(task_header: __main__.TaskOutputHeader*)", + "type": "type_definition" + }, + "__main__.parse_task_header.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.parse_task_header.task_header": { + "cairo_type": "__main__.TaskOutputHeader*", + "full_name": "__main__.parse_task_header.task_header", + "references": [ + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "[cast(fp + (-3), __main__.TaskOutputHeader**)]" + } + ], + "type": "reference" + }, + "__main__.parse_task_header.task_output": { + "cairo_type": "felt*", + "full_name": "__main__.parse_task_header.task_output", + "references": [ + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "cast([fp + (-3)] + 2, felt*)" + } + ], + "type": "reference" + }, + "__main__.parse_tasks": { + "decorators": [], + "pc": 590, + "type": "function" + }, + "__main__.parse_tasks.Args": { + "full_name": "__main__.parse_tasks.Args", + "members": { + "bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "offset": 0 + }, + "n_subtasks": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "__main__.parse_tasks.ImplicitArgs": { + "full_name": "__main__.parse_tasks.ImplicitArgs", + "members": { + "n_total_tasks": { + "cairo_type": "felt", + "offset": 4 + }, + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 2 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "subtasks_output": { + "cairo_type": "felt*", + "offset": 5 + } + }, + "size": 6, + "type": "struct" + }, + "__main__.parse_tasks.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.parse_tasks.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.parse_tasks.__temp54": { + "cairo_type": "felt", + "full_name": "__main__.parse_tasks.__temp54", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 1 + }, + "pc": 603, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "full_name": "__main__.parse_tasks.bootloader_config", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-4), __main__.BootloaderConfig**)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.n_subtasks": { + "cairo_type": "felt", + "full_name": "__main__.parse_tasks.n_subtasks", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.n_total_tasks": { + "cairo_type": "felt", + "full_name": "__main__.parse_tasks.n_total_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-2), felt*)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.parse_tasks.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-10), felt**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-6), felt**)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "__main__.parse_tasks.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-9), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "__main__.parse_tasks.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.range_check_ptr": { + "cairo_type": "felt", + "full_name": "__main__.parse_tasks.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-3), felt*)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.subtasks_output": { + "cairo_type": "felt*", + "full_name": "__main__.parse_tasks.subtasks_output", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "__main__.poseidon_hash_many": { + "destination": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many", + "type": "alias" + }, + "__main__.run_simple_bootloader": { + "destination": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader", + "type": "alias" + }, + "__main__.serialize_bootloader_config": { + "decorators": [], + "pc": 631, + "type": "function" + }, + "__main__.serialize_bootloader_config.Args": { + "full_name": "__main__.serialize_bootloader_config.Args", + "members": { + "bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.serialize_bootloader_config.ImplicitArgs": { + "full_name": "__main__.serialize_bootloader_config.ImplicitArgs", + "members": { + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "__main__.serialize_bootloader_config.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.serialize_bootloader_config.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.serialize_bootloader_config.__temp55": { + "cairo_type": "felt", + "full_name": "__main__.serialize_bootloader_config.__temp55", + "references": [ + { + "ap_tracking_data": { + "group": 52, + "offset": 1 + }, + "pc": 632, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.serialize_bootloader_config.bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "full_name": "__main__.serialize_bootloader_config.bootloader_config", + "references": [ + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + } + ], + "type": "reference" + }, + "__main__.serialize_bootloader_config.output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.serialize_bootloader_config.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 639, + "value": "cast([fp + (-5)] + 2, felt*)" + } + ], + "type": "reference" + }, + "__main__.serialize_bootloader_config.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "__main__.serialize_bootloader_config.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 638, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": { + "cairo_type": "felt", + "full_name": "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash", + "references": [ + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 638, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task": { + "decorators": [], + "pc": 647, + "type": "function" + }, + "__main__.unpack_composite_packed_task.Args": { + "full_name": "__main__.unpack_composite_packed_task.Args", + "members": { + "bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.unpack_composite_packed_task.ImplicitArgs": { + "full_name": "__main__.unpack_composite_packed_task.ImplicitArgs", + "members": { + "n_total_tasks": { + "cairo_type": "felt", + "offset": 4 + }, + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 2 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "task_output": { + "cairo_type": "felt*", + "offset": 5 + } + }, + "size": 6, + "type": "struct" + }, + "__main__.unpack_composite_packed_task.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.unpack_composite_packed_task.SIZEOF_LOCALS": { + "type": "const", + "value": 4 + }, + "__main__.unpack_composite_packed_task.__temp56": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.__temp56", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 6 + }, + "pc": 659, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.__temp57": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.__temp57", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 669, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "full_name": "__main__.unpack_composite_packed_task.bootloader_config", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.n_subtasks": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.n_subtasks", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "[cast([fp], felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.n_total_tasks": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.n_total_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-2), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.nested_subtasks_output": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_composite_packed_task.nested_subtasks_output", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 4 + }, + "pc": 649, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "cast([fp] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.nested_subtasks_output_len", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 4 + }, + "pc": 649, + "value": "[cast(fp + 1, felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_composite_packed_task.nested_subtasks_output_start", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "[cast(fp + 3, felt**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_composite_packed_task.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-6), felt**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "__main__.unpack_composite_packed_task.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "__main__.unpack_composite_packed_task.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 0 + }, + "pc": 654, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.range_check_ptr": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 37 + }, + "pc": 668, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-3), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.subtasks_output_hash": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.subtasks_output_hash", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 0 + }, + "pc": 654, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.task_header": { + "cairo_type": "__main__.TaskOutputHeader*", + "full_name": "__main__.unpack_composite_packed_task.task_header", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 5 + }, + "pc": 657, + "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.task_output": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_composite_packed_task.task_output", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 5 + }, + "pc": 657, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 673, + "value": "[cast(fp + 2, felt**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task": { + "decorators": [], + "pc": 693, + "type": "function" + }, + "__main__.unpack_plain_packed_task.Args": { + "full_name": "__main__.unpack_plain_packed_task.Args", + "members": { + "bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.unpack_plain_packed_task.ImplicitArgs": { + "full_name": "__main__.unpack_plain_packed_task.ImplicitArgs", + "members": { + "n_total_tasks": { + "cairo_type": "felt", + "offset": 4 + }, + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 2 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "task_output": { + "cairo_type": "felt*", + "offset": 5 + } + }, + "size": 6, + "type": "struct" + }, + "__main__.unpack_plain_packed_task.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.unpack_plain_packed_task.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "__main__.unpack_plain_packed_task.__temp58": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.__temp58", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 8 + }, + "pc": 700, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.__temp59": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.__temp59", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 9 + }, + "pc": 702, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.__temp60": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.__temp60", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 10 + }, + "pc": 704, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.__temp61": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.__temp61", + "references": [ + { + "ap_tracking_data": { + "group": 59, + "offset": 1 + }, + "pc": 714, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "full_name": "__main__.unpack_plain_packed_task.bootloader_config", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.n_total_tasks": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.n_total_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp + (-5)] + 1, felt)" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_plain_packed_task.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 9 + }, + "pc": 703, + "value": "cast([fp + (-9)] + 2, felt*)" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp + (-9)] + 2 + [fp + 1], felt*)" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.output_size": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.output_size", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 10 + }, + "pc": 706, + "value": "[cast(fp + 1, felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "__main__.unpack_plain_packed_task.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "__main__.unpack_plain_packed_task.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.range_check_ptr": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-6), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.task_header": { + "cairo_type": "__main__.TaskOutputHeader*", + "full_name": "__main__.unpack_plain_packed_task.task_header", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 698, + "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.task_output": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_plain_packed_task.task_output", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 698, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 699, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp] + [fp + 1], felt*)" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.BOOTLOADER_VERSION": { + "type": "const", + "value": 0 + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "members": { + "bitwise": { + "cairo_type": "felt", + "offset": 4 + }, + "ec_op": { + "cairo_type": "felt", + "offset": 5 + }, + "ecdsa": { + "cairo_type": "felt", + "offset": 3 + }, + "keccak": { + "cairo_type": "felt", + "offset": 6 + }, + "output": { + "cairo_type": "felt", + "offset": 0 + }, + "pedersen": { + "cairo_type": "felt", + "offset": 1 + }, + "poseidon": { + "cairo_type": "felt", + "offset": 7 + }, + "range_check": { + "cairo_type": "felt", + "offset": 2 + }, + "range_check96": { + "cairo_type": "felt", + "offset": 8 + } + }, + "size": 9, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinList": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinList", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.PoseidonBuiltin": { + "destination": "starkware.cairo.common.builtin_poseidon.poseidon.PoseidonBuiltin", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader", + "members": { + "bootloader_version": { + "cairo_type": "felt", + "offset": 1 + }, + "builtin_list": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinList", + "offset": 4 + }, + "data_length": { + "cairo_type": "felt", + "offset": 0 + }, + "n_builtins": { + "cairo_type": "felt", + "offset": 3 + }, + "program_main": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash": { + "decorators": [], + "pc": 209, + "type": "function" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.Args": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.Args", + "members": { + "program_data_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "use_poseidon": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.ImplicitArgs": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.Return": { + "cairo_type": "(hash: felt)", + "type": "type_definition" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 1 + }, + "pc": 211, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash", + "references": [ + { + "ap_tracking_data": { + "group": 14, + "offset": 0 + }, + "pc": 219, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 15, + "offset": 0 + }, + "pc": 227, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 15, + "offset": 0 + }, + "pc": 227, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 14, + "offset": 0 + }, + "pc": 219, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task": { + "decorators": [], + "pc": 231, + "type": "function" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.Args": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.Args", + "members": { + "builtin_encodings": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 0 + }, + "builtin_instance_sizes": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 1 + }, + "use_poseidon": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ImplicitArgs": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ImplicitArgs", + "members": { + "builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 0 + }, + "self_range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.SIZEOF_LOCALS": { + "type": "const", + "value": 26 + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 235, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 239, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val", + "references": [ + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 275, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 249, + "value": "[cast(fp + 3, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 298, + "value": "cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.call_task": { + "pc": 272, + "type": "label" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 250, + "value": "[cast(fp + 4, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 237, + "value": "[cast(fp + 2, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size", + "references": [ + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 297, + "value": "[cast(fp + 25, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 240, + "value": "[cast([fp + (-7)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-3), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 240, + "value": "[cast([fp + (-7)] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 263, + "value": "[cast(fp + 6, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 1 + }, + "pc": 251, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp + 1, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 253, + "value": "[cast(fp + 5, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 237, + "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 252, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ret_pc_label": { + "pc": 273, + "type": "label" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 276, + "value": "[cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": { + "cairo_type": "(selected_encodings_end: felt*)", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret", + "references": [ + { + "ap_tracking_data": { + "group": 20, + "offset": 0 + }, + "pc": 285, + "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 296, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr", + "references": [ + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 276, + "value": "[cast(fp + 15, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.get_ap": { + "destination": "starkware.cairo.common.registers.get_ap", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.hash_chain": { + "destination": "starkware.cairo.common.hash_chain.hash_chain", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.inner_select_builtins": { + "destination": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.poseidon_hash_many": { + "destination": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.select_input_builtins": { + "destination": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.validate_builtins": { + "destination": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.BuiltinData": { + "destination": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.PoseidonBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_task": { + "destination": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks": { + "decorators": [], + "pc": 396, + "type": "function" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.Args": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.Args", + "members": { + "builtin_encodings": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 0 + }, + "builtin_instance_sizes": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 1 + }, + "n_tasks": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.ImplicitArgs": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.ImplicitArgs", + "members": { + "builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 0 + }, + "self_range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 28, + "offset": 0 + }, + "pc": 410, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 29, + "offset": 0 + }, + "pc": 416, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 28, + "offset": 0 + }, + "pc": 410, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 29, + "offset": 0 + }, + "pc": 416, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 1 + }, + "pc": 403, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader": { + "decorators": [], + "pc": 302, + "type": "function" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.Args": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ImplicitArgs": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ImplicitArgs", + "members": { + "bitwise_ptr": { + "cairo_type": "felt", + "offset": 4 + }, + "ec_op_ptr": { + "cairo_type": "felt", + "offset": 5 + }, + "ecdsa_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "keccak_ptr": { + "cairo_type": "felt", + "offset": 6 + }, + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 7 + }, + "range_check96_ptr": { + "cairo_type": "felt", + "offset": 8 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 9, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.SIZEOF_LOCALS": { + "type": "const", + "value": 29 + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "[cast(ap + (-2), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47", + "references": [ + { + "ap_tracking_data": { + "group": 23, + "offset": 1 + }, + "pc": 365, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks", + "references": [ + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "cast([[fp + 28] + 2] - [ap + (-1)], felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 4, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 332, + "value": "[cast(fp + 10, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 350, + "value": "[cast(fp + 19, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 362, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast(fp + 28, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 314, + "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 5, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-8), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 3, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 6, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "[cast([fp + (-11)], felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-11), felt**)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "cast([fp + (-11)] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28], felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 8, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 2, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 362, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "[cast(fp, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative": { + "decorators": [], + "pc": 380, + "type": "function" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.Args": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.Args", + "members": { + "n_bits": { + "cairo_type": "felt", + "offset": 1 + }, + "num": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.ImplicitArgs": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48", + "references": [ + { + "ap_tracking_data": { + "group": 25, + "offset": 2 + }, + "pc": 388, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit", + "references": [ + { + "ap_tracking_data": { + "group": 25, + "offset": 3 + }, + "pc": 389, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits", + "references": [ + { + "ap_tracking_data": { + "group": 25, + "offset": 0 + }, + "pc": 380, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num", + "references": [ + { + "ap_tracking_data": { + "group": 25, + "offset": 0 + }, + "pc": 380, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2", + "references": [ + { + "ap_tracking_data": { + "group": 25, + "offset": 1 + }, + "pc": 387, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins": { + "decorators": [], + "pc": 6, + "type": "function" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.Args": { + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.Args", + "members": { + "all_encodings": { + "cairo_type": "felt*", + "offset": 0 + }, + "all_ptrs": { + "cairo_type": "felt*", + "offset": 1 + }, + "n_builtins": { + "cairo_type": "felt", + "offset": 4 + }, + "selected_encodings": { + "cairo_type": "felt*", + "offset": 2 + }, + "selected_ptrs": { + "cairo_type": "felt*", + "offset": 3 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.FUNC_MEMORY_NO_BUILTINS": { + "type": "const", + "value": 1 + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.FUNC_MEMORY_WITH_BUILTINS": { + "type": "const", + "value": 10 + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.ImplicitArgs": { + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.Return": { + "cairo_type": "(selected_encodings_end: felt*)", + "type": "type_definition" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.SIZEOF_LOCALS": { + "type": "const", + "value": 3 + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-7), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-6), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 14, + "value": "[cast(fp + 1, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 15, + "value": "[cast(fp + 2, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 12, + "value": "[cast(fp, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-5), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.builtin_selection.select_input_builtins.inner_select_builtins": { + "destination": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins", + "type": "alias" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins": { + "decorators": [], + "pc": 32, + "type": "function" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.Args": { + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.Args", + "members": { + "all_encodings": { + "cairo_type": "felt*", + "offset": 0 + }, + "all_ptrs": { + "cairo_type": "felt*", + "offset": 1 + }, + "n_all_builtins": { + "cairo_type": "felt", + "offset": 2 + }, + "n_selected_builtins": { + "cairo_type": "felt", + "offset": 4 + }, + "selected_encodings": { + "cairo_type": "felt*", + "offset": 3 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.FUNC_MEMORY_WITHOUT_INNER_FUNC": { + "type": "const", + "value": 11 + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.INNER_FUNC_MEMORY_FINAL_ITERATION": { + "type": "const", + "value": 1 + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.INNER_FUNC_MEMORY_PER_ITERATION": { + "type": "const", + "value": 10 + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.ImplicitArgs": { + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 3 + }, + "pc": 36, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 4 + }, + "pc": 38, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-7), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-6), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": { + "cairo_type": "(fp_val: felt*, pc_val: felt*)", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 2 + }, + "pc": 34, + "value": "[cast(ap + (-2), (fp_val: felt*, pc_val: felt*)*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "cast([fp + (-5)] * 10 + 1, felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": { + "cairo_type": "(selected_encodings_end: felt*)", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret", + "references": [ + { + "ap_tracking_data": { + "group": 5, + "offset": 0 + }, + "pc": 45, + "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-5), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 2 + }, + "pc": 34, + "value": "cast([ap + (-2)] + [fp + (-5)] * 10 + 12, felt*)" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "cast([fp + (-5)] * 10 + 12, felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin": { + "decorators": [], + "pc": 48, + "type": "function" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.Args": { + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.Args", + "members": { + "builtin_instance_size": { + "cairo_type": "felt", + "offset": 2 + }, + "new_builtin_ptr": { + "cairo_type": "felt*", + "offset": 1 + }, + "prev_builtin_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.ImplicitArgs": { + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 1 + }, + "pc": 49, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 2 + }, + "pc": 50, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-5), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 2 + }, + "pc": 51, + "value": "cast([fp + (-6)] + 1, felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins": { + "decorators": [], + "pc": 54, + "type": "function" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.Args": { + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.Args", + "members": { + "builtin_instance_sizes": { + "cairo_type": "felt*", + "offset": 2 + }, + "n_builtins": { + "cairo_type": "felt", + "offset": 3 + }, + "new_builtin_ptrs": { + "cairo_type": "felt*", + "offset": 1 + }, + "prev_builtin_ptrs": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.ImplicitArgs": { + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-5), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-6), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 9 + }, + "pc": 64, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 9, + "offset": 0 + }, + "pc": 74, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.cairo_verifier.objects.CairoVerifierOutput": { + "full_name": "starkware.cairo.cairo_verifier.objects.CairoVerifierOutput", + "members": { + "output_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "program_hash": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.bool.FALSE": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.bool.TRUE": { + "type": "const", + "value": 1 + }, + "starkware.cairo.common.builtin_poseidon.poseidon.PoseidonBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", + "type": "alias" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.PoseidonBuiltinState": { + "destination": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "type": "alias" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many": { + "decorators": [], + "pc": 75, + "type": "function" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.Args": { + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.Args", + "members": { + "elements": { + "cairo_type": "felt*", + "offset": 1 + }, + "n": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.ImplicitArgs": { + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.ImplicitArgs", + "members": { + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.Return": { + "cairo_type": "(res: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 14 + }, + "pc": 101, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 15 + }, + "pc": 102, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 16 + }, + "pc": 103, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 105, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 18 + }, + "pc": 107, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 19 + }, + "pc": 108, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 20 + }, + "pc": 109, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 21 + }, + "pc": 111, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 22 + }, + "pc": 112, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 23 + }, + "pc": 113, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 6 + }, + "pc": 85, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 115, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 25 + }, + "pc": 117, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 26 + }, + "pc": 118, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 27 + }, + "pc": 119, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 28 + }, + "pc": 121, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 29 + }, + "pc": 122, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 30 + }, + "pc": 123, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 125, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 32 + }, + "pc": 127, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 33 + }, + "pc": 128, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 7 + }, + "pc": 90, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 34 + }, + "pc": 129, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 35 + }, + "pc": 131, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 36 + }, + "pc": 132, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 37 + }, + "pc": 133, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 135, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 7 + }, + "pc": 147, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 152, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 153, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 155, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 156, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 91, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 168, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 173, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 183, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 184, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 187, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 93, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 94, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 97, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 98, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 13 + }, + "pc": 99, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 4 + }, + "pc": 82, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 42 + }, + "pc": 141, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 15 + }, + "pc": 163, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "cast([fp + (-3)] + [fp + (-4)], felt*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.loop": { + "pc": 83, + "type": "label" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 169, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 5 + }, + "pc": 83, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 96, + "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 106, + "value": "cast([ap + (-13)] + 12, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 116, + "value": "cast([ap + (-20)] + 18, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 126, + "value": "cast([ap + (-27)] + 24, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 136, + "value": "cast([ap + (-34)] + 30, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 43 + }, + "pc": 143, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 158, + "value": "cast([ap + (-7)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 16 + }, + "pc": 165, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 176, + "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 189, + "value": "cast([ap + (-8)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 176, + "value": "[cast([ap + (-6)] + 3, felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 189, + "value": "[cast([ap + (-8)] + 3, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": { + "cairo_type": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 3 + }, + "pc": 81, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 96, + "value": "[cast([ap + (-6)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 106, + "value": "[cast([ap + (-13)] + 9, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 116, + "value": "[cast([ap + (-20)] + 15, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 126, + "value": "[cast([ap + (-27)] + 21, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 136, + "value": "[cast([ap + (-34)] + 27, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 41 + }, + "pc": 139, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 158, + "value": "[cast([ap + (-7)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 14 + }, + "pc": 161, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.cairo_builtins.BitwiseBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "x_and_y": { + "cairo_type": "felt", + "offset": 2 + }, + "x_or_y": { + "cairo_type": "felt", + "offset": 4 + }, + "x_xor_y": { + "cairo_type": "felt", + "offset": 3 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.EcOpBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.EcOpBuiltin", + "members": { + "m": { + "cairo_type": "felt", + "offset": 4 + }, + "p": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 0 + }, + "q": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 2 + }, + "r": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 5 + } + }, + "size": 7, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.EcPoint": { + "destination": "starkware.cairo.common.ec_point.EcPoint", + "type": "alias" + }, + "starkware.cairo.common.cairo_builtins.HashBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "members": { + "result": { + "cairo_type": "felt", + "offset": 2 + }, + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.KeccakBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.KeccakBuiltin", + "members": { + "input": { + "cairo_type": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "offset": 0 + }, + "output": { + "cairo_type": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "offset": 8 + } + }, + "size": 16, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.KeccakBuiltinState": { + "destination": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "type": "alias" + }, + "starkware.cairo.common.cairo_builtins.PoseidonBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", + "members": { + "input": { + "cairo_type": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "offset": 0 + }, + "output": { + "cairo_type": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "offset": 3 + } + }, + "size": 6, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.PoseidonBuiltinState": { + "destination": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "type": "alias" + }, + "starkware.cairo.common.cairo_builtins.SignatureBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", + "members": { + "message": { + "cairo_type": "felt", + "offset": 1 + }, + "pub_key": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.ec_point.EcPoint": { + "full_name": "starkware.cairo.common.ec_point.EcPoint", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.find_element.FIND_ELEMENT_RANGE_CHECK_USAGE": { + "type": "const", + "value": 2 + }, + "starkware.cairo.common.find_element.assert_le": { + "destination": "starkware.cairo.common.math.assert_le", + "type": "alias" + }, + "starkware.cairo.common.find_element.assert_le_felt": { + "destination": "starkware.cairo.common.math.assert_le_felt", + "type": "alias" + }, + "starkware.cairo.common.find_element.assert_lt_felt": { + "destination": "starkware.cairo.common.math.assert_lt_felt", + "type": "alias" + }, + "starkware.cairo.common.find_element.assert_nn_le": { + "destination": "starkware.cairo.common.math.assert_nn_le", + "type": "alias" + }, + "starkware.cairo.common.find_element.find_element": { + "decorators": [], + "pc": 435, + "type": "function" + }, + "starkware.cairo.common.find_element.find_element.Args": { + "full_name": "starkware.cairo.common.find_element.find_element.Args", + "members": { + "array_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "elm_size": { + "cairo_type": "felt", + "offset": 1 + }, + "key": { + "cairo_type": "felt", + "offset": 3 + }, + "n_elms": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.cairo.common.find_element.find_element.ImplicitArgs": { + "full_name": "starkware.cairo.common.find_element.find_element.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.find_element.find_element.Return": { + "cairo_type": "(elm_ptr: felt*)", + "type": "type_definition" + }, + "starkware.cairo.common.find_element.find_element.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "starkware.cairo.common.find_element.find_element.__temp49": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.__temp49", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 21 + }, + "pc": 444, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.array_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.find_element.find_element.array_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-6), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.elm_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.find_element.find_element.elm_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 22 + }, + "pc": 445, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.elm_size": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.elm_size", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-5), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.index": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.index", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 1 + }, + "pc": 437, + "value": "[cast(fp, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.key": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.key", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.n_elms": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.n_elms", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 20 + }, + "pc": 443, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.common.hash.hash2": { + "decorators": [], + "pc": 449, + "type": "function" + }, + "starkware.cairo.common.hash.hash2.Args": { + "full_name": "starkware.cairo.common.hash.hash2.Args", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash.hash2.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash.hash2.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash.hash2.Return": { + "cairo_type": "(result: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash.hash2.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.hash.hash2.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash.hash2.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 451, + "value": "cast([fp + (-5)] + 3, starkware.cairo.common.cairo_builtins.HashBuiltin*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash.hash2.result": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash.hash2.result", + "references": [ + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 451, + "value": "[cast([fp + (-5)] + 2, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash.hash2.x": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash.hash2.x", + "references": [ + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash.hash2.y": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash.hash2.y", + "references": [ + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.common.hash_chain.hash_chain": { + "decorators": [], + "pc": 193, + "type": "function" + }, + "starkware.cairo.common.hash_chain.hash_chain.Args": { + "full_name": "starkware.cairo.common.hash_chain.hash_chain.Args", + "members": { + "data_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_chain.hash_chain.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_chain.hash_chain.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_chain.hash_chain.LoopLocals": { + "full_name": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals", + "members": { + "cur_hash": { + "cairo_type": "felt", + "offset": 2 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_chain.hash_chain.Return": { + "cairo_type": "(hash: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_chain.hash_chain.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": { + "cairo_type": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals*", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.curr_frame", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.current_hash", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.data_length": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.data_length", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 1 + }, + "pc": 194, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.data_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 0 + }, + "pc": 193, + "value": "[cast(fp + (-3), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 2 + }, + "pc": 195, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.hash_loop": { + "pc": 197, + "type": "label" + }, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 0 + }, + "pc": 193, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 9 + }, + "pc": 208, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": { + "cairo_type": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.loop_frame", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 5 + }, + "pc": 198, + "value": "[cast(ap, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.new_data": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.new_data", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 5 + }, + "pc": 198, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.next_frame": { + "cairo_type": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.next_frame", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 9 + }, + "pc": 205, + "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.common.hash_state.HashState": { + "full_name": "starkware.cairo.common.hash_state.HashState", + "members": { + "current_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "n_words": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash_state.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.common.hash_state.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "starkware.cairo.common.hash_state.hash_felts": { + "decorators": [], + "pc": 512, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_felts.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_felts.Args", + "members": { + "data": { + "cairo_type": "felt*", + "offset": 0 + }, + "length": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_felts.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_felts.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_felts.Return": { + "cairo_type": "(hash: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_felts.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.hash_state.hash_felts.data": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_felts.data", + "references": [ + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_state.hash_felts.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 0 + }, + "pc": 520, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 9 + }, + "pc": 522, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "full_name": "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 40, + "offset": 7 + }, + "pc": 514, + "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 0 + }, + "pc": 520, + "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts.length": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts.length", + "references": [ + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding": { + "decorators": [], + "pc": 487, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.Args", + "members": { + "data_length": { + "cairo_type": "felt", + "offset": 1 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "initial_hash": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals": { + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals", + "members": { + "cur_hash": { + "cairo_type": "felt", + "offset": 2 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.Return": { + "cairo_type": "(hash: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 496, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 7 + }, + "pc": 503, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 497, + "value": "[cast(fp, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-5), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.final_locals": { + "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.final_locals", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 10 + }, + "pc": 511, + "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": { + "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 497, + "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_loop": { + "pc": 500, + "type": "label" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 10 + }, + "pc": 511, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 6 + }, + "pc": 501, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": { + "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 7 + }, + "pc": 504, + "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": { + "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 5 + }, + "pc": 500, + "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_finalize": { + "decorators": [], + "pc": 481, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_finalize.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_finalize.Args", + "members": { + "hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_finalize.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_finalize.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_finalize.Return": { + "cairo_type": "(hash: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_finalize.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.hash_state.hash_finalize.hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_finalize.hash", + "references": [ + { + "ap_tracking_data": { + "group": 38, + "offset": 7 + }, + "pc": 486, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_state.hash_finalize.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 38, + "offset": 0 + }, + "pc": 481, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 38, + "offset": 7 + }, + "pc": 486, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "full_name": "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 38, + "offset": 0 + }, + "pc": 481, + "value": "[cast(fp + (-3), starkware.cairo.common.hash_state.HashState**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_init": { + "decorators": [], + "pc": 455, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_init.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_init.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_init.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_init.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_init.Return": { + "cairo_type": "(hash_state_ptr: starkware.cairo.common.hash_state.HashState*)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_init.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.cairo.common.hash_state.hash_init.__fp__": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_init.__fp__", + "references": [ + { + "ap_tracking_data": { + "group": 35, + "offset": 4 + }, + "pc": 459, + "value": "[cast(ap + (-2), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_init.hash_state": { + "cairo_type": "starkware.cairo.common.hash_state.HashState", + "full_name": "starkware.cairo.common.hash_state.hash_init.hash_state", + "references": [ + { + "ap_tracking_data": { + "group": 35, + "offset": 4 + }, + "pc": 459, + "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update": { + "decorators": [], + "pc": 465, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_update.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_update.Args", + "members": { + "data_length": { + "cairo_type": "felt", + "offset": 2 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 1 + }, + "hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_update.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update.Return": { + "cairo_type": "(new_hash_state_ptr: starkware.cairo.common.hash_state.HashState*)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_update.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.cairo.common.hash_state.hash_update.__fp__": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_update.__fp__", + "references": [ + { + "ap_tracking_data": { + "group": 37, + "offset": 2 + }, + "pc": 475, + "value": "[cast(ap + (-2), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.__temp50": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_update.__temp50", + "references": [ + { + "ap_tracking_data": { + "group": 37, + "offset": 3 + }, + "pc": 477, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.data_length": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_update.data_length", + "references": [ + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.data_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_update.data_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_update.hash", + "references": [ + { + "ap_tracking_data": { + "group": 37, + "offset": 0 + }, + "pc": 473, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_state.hash_update.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 0 + }, + "pc": 473, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "full_name": "starkware.cairo.common.hash_state.hash_update.hash_state_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-5), starkware.cairo.common.hash_state.HashState**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": { + "cairo_type": "starkware.cairo.common.hash_state.HashState", + "full_name": "starkware.cairo.common.hash_state.hash_update.new_hash_state", + "references": [ + { + "ap_tracking_data": { + "group": 37, + "offset": 2 + }, + "pc": 475, + "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.keccak_state.KeccakBuiltinState": { + "full_name": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "members": { + "s0": { + "cairo_type": "felt", + "offset": 0 + }, + "s1": { + "cairo_type": "felt", + "offset": 1 + }, + "s2": { + "cairo_type": "felt", + "offset": 2 + }, + "s3": { + "cairo_type": "felt", + "offset": 3 + }, + "s4": { + "cairo_type": "felt", + "offset": 4 + }, + "s5": { + "cairo_type": "felt", + "offset": 5 + }, + "s6": { + "cairo_type": "felt", + "offset": 6 + }, + "s7": { + "cairo_type": "felt", + "offset": 7 + } + }, + "size": 8, + "type": "struct" + }, + "starkware.cairo.common.math.FALSE": { + "destination": "starkware.cairo.common.bool.FALSE", + "type": "alias" + }, + "starkware.cairo.common.math.TRUE": { + "destination": "starkware.cairo.common.bool.TRUE", + "type": "alias" + }, + "starkware.cairo.common.math.assert_le": { + "decorators": [], + "pc": 421, + "type": "function" + }, + "starkware.cairo.common.math.assert_le.Args": { + "full_name": "starkware.cairo.common.math.assert_le.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + }, + "b": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.math.assert_le.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_le.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_le.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_le.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_le.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_le.a", + "references": [ + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_le.b": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_le.b", + "references": [ + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_le.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_le.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 31, + "offset": 5 + }, + "pc": 425, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_nn": { + "decorators": [], + "pc": 417, + "type": "function" + }, + "starkware.cairo.common.math.assert_nn.Args": { + "full_name": "starkware.cairo.common.math.assert_nn.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_nn.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_nn.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_nn.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_nn.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_nn.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn.a", + "references": [ + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 417, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_nn.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 417, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 418, + "value": "cast([fp + (-4)] + 1, felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_nn_le": { + "decorators": [], + "pc": 426, + "type": "function" + }, + "starkware.cairo.common.math.assert_nn_le.Args": { + "full_name": "starkware.cairo.common.math.assert_nn_le.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + }, + "b": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.math.assert_nn_le.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_nn_le.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_nn_le.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_nn_le.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_nn_le.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn_le.a", + "references": [ + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_nn_le.b": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn_le.b", + "references": [ + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn_le.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 5 + }, + "pc": 430, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 14 + }, + "pc": 434, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy": { + "decorators": [], + "pc": 523, + "type": "function" + }, + "starkware.cairo.common.memcpy.memcpy.Args": { + "full_name": "starkware.cairo.common.memcpy.memcpy.Args", + "members": { + "dst": { + "cairo_type": "felt*", + "offset": 0 + }, + "len": { + "cairo_type": "felt", + "offset": 2 + }, + "src": { + "cairo_type": "felt*", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.ImplicitArgs": { + "full_name": "starkware.cairo.common.memcpy.memcpy.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.LoopFrame": { + "full_name": "starkware.cairo.common.memcpy.memcpy.LoopFrame", + "members": { + "dst": { + "cairo_type": "felt*", + "offset": 0 + }, + "src": { + "cairo_type": "felt*", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.memcpy.memcpy.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.memcpy.memcpy.__temp53": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.memcpy.memcpy.__temp53", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 529, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.continue_copying": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.memcpy.memcpy.continue_copying", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 530, + "value": "[cast(ap, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.dst": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.memcpy.memcpy.dst", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-5), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.frame": { + "cairo_type": "starkware.cairo.common.memcpy.memcpy.LoopFrame", + "full_name": "starkware.cairo.common.memcpy.memcpy.frame", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 2 + }, + "pc": 528, + "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 2 + }, + "pc": 528, + "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.len": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.memcpy.memcpy.len", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.loop": { + "pc": 528, + "type": "label" + }, + "starkware.cairo.common.memcpy.memcpy.next_frame": { + "cairo_type": "starkware.cairo.common.memcpy.memcpy.LoopFrame*", + "full_name": "starkware.cairo.common.memcpy.memcpy.next_frame", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 530, + "value": "cast(ap + 1, starkware.cairo.common.memcpy.memcpy.LoopFrame*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.src": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.memcpy.memcpy.src", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.poseidon_state.PoseidonBuiltinState": { + "full_name": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "members": { + "s0": { + "cairo_type": "felt", + "offset": 0 + }, + "s1": { + "cairo_type": "felt", + "offset": 1 + }, + "s2": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.registers.get_ap": { + "destination": "starkware.cairo.lang.compiler.lib.registers.get_ap", + "type": "alias" + }, + "starkware.cairo.common.registers.get_fp_and_pc": { + "destination": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap": { + "decorators": [ + "known_ap_change" + ], + "pc": 1, + "type": "function" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.Args": { + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.ImplicitArgs": { + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.Return": { + "cairo_type": "(ap_val: felt*)", + "type": "type_definition" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val", + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 2 + }, + "pc": 3, + "value": "[cast(ap + (-2), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val", + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 2 + }, + "pc": 3, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc": { + "decorators": [], + "pc": 0, + "type": "function" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Args": { + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.ImplicitArgs": { + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Return": { + "cairo_type": "(fp_val: felt*, pc_val: felt*)", + "type": "type_definition" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + } + }, + "main_scope": "__main__", + "prime": "0x800000000000011000000000000000000000000000000000000000000000001", + "reference_manager": { + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 2 + }, + "pc": 3, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 1, + "offset": 2 + }, + "pc": 3, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 12, + "value": "[cast(fp, felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 14, + "value": "[cast(fp + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 15, + "value": "[cast(fp + 2, felt*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "cast([fp + (-5)] * 10 + 1, felt)" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "cast([fp + (-5)] * 10 + 12, felt)" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 2 + }, + "pc": 34, + "value": "[cast(ap + (-2), (fp_val: felt*, pc_val: felt*)*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 2 + }, + "pc": 34, + "value": "cast([ap + (-2)] + [fp + (-5)] * 10 + 12, felt*)" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 3 + }, + "pc": 36, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 4 + }, + "pc": 38, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 5, + "offset": 0 + }, + "pc": 45, + "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 1 + }, + "pc": 49, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 2 + }, + "pc": 50, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 2 + }, + "pc": 51, + "value": "cast([fp + (-6)] + 1, felt)" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 9 + }, + "pc": 64, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 9, + "offset": 0 + }, + "pc": 74, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "cast([fp + (-3)] + [fp + (-4)], felt*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 3 + }, + "pc": 81, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 4 + }, + "pc": 82, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 5 + }, + "pc": 83, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 6 + }, + "pc": 85, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 7 + }, + "pc": 90, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 91, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 93, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 94, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 96, + "value": "[cast([ap + (-6)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 96, + "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 97, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 98, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 13 + }, + "pc": 99, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 14 + }, + "pc": 101, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 15 + }, + "pc": 102, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 16 + }, + "pc": 103, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 105, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 106, + "value": "[cast([ap + (-13)] + 9, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 106, + "value": "cast([ap + (-13)] + 12, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 18 + }, + "pc": 107, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 19 + }, + "pc": 108, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 20 + }, + "pc": 109, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 21 + }, + "pc": 111, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 22 + }, + "pc": 112, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 23 + }, + "pc": 113, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 115, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 116, + "value": "[cast([ap + (-20)] + 15, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 116, + "value": "cast([ap + (-20)] + 18, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 25 + }, + "pc": 117, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 26 + }, + "pc": 118, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 27 + }, + "pc": 119, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 28 + }, + "pc": 121, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 29 + }, + "pc": 122, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 30 + }, + "pc": 123, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 125, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 126, + "value": "[cast([ap + (-27)] + 21, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 126, + "value": "cast([ap + (-27)] + 24, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 32 + }, + "pc": 127, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 33 + }, + "pc": 128, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 34 + }, + "pc": 129, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 35 + }, + "pc": 131, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 36 + }, + "pc": 132, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 37 + }, + "pc": 133, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 135, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 136, + "value": "[cast([ap + (-34)] + 27, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 136, + "value": "cast([ap + (-34)] + 30, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 41 + }, + "pc": 139, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 42 + }, + "pc": 141, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 43 + }, + "pc": 143, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 7 + }, + "pc": 147, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 152, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 153, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 155, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 156, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 158, + "value": "[cast([ap + (-7)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 158, + "value": "cast([ap + (-7)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 14 + }, + "pc": 161, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 15 + }, + "pc": 163, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 16 + }, + "pc": 165, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 141, + "value": "[cast(ap - 1 + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 143, + "value": "[cast(ap - 0 + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 139, + "value": "[cast(ap - 2 + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 168, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 169, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 173, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 176, + "value": "[cast([ap + (-6)] + 3, felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 176, + "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 183, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 184, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 187, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 189, + "value": "[cast([ap + (-8)] + 3, felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 189, + "value": "cast([ap + (-8)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 0 + }, + "pc": 193, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 0 + }, + "pc": 193, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 1 + }, + "pc": 194, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 2 + }, + "pc": 195, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 5 + }, + "pc": 198, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 5 + }, + "pc": 198, + "value": "[cast(ap, felt*)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 9 + }, + "pc": 205, + "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 9 + }, + "pc": 208, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 1 + }, + "pc": 211, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 14, + "offset": 0 + }, + "pc": 219, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 14, + "offset": 0 + }, + "pc": 219, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 15, + "offset": 0 + }, + "pc": 227, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 15, + "offset": 0 + }, + "pc": 227, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 235, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp + 1, felt**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 237, + "value": "[cast(fp + 2, felt*)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 237, + "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 239, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 240, + "value": "[cast([fp + (-7)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 240, + "value": "[cast([fp + (-7)] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-3), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 249, + "value": "[cast(fp + 3, felt**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 250, + "value": "[cast(fp + 4, felt*)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 1 + }, + "pc": 251, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 252, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 253, + "value": "[cast(fp + 5, felt**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 263, + "value": "[cast(fp + 6, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + }, + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 275, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 276, + "value": "[cast(fp + 15, felt**)]" + }, + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 276, + "value": "[cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + }, + { + "ap_tracking_data": { + "group": 20, + "offset": 0 + }, + "pc": 285, + "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" + }, + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 296, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 297, + "value": "[cast(fp + 25, felt*)]" + }, + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 298, + "value": "cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-11), felt**)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-8), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "[cast(fp, felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "[cast([fp + (-11)], felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "cast([fp + (-11)] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 314, + "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 332, + "value": "[cast(fp + 10, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 350, + "value": "[cast(fp + 19, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 362, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 362, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast(fp + 28, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28], felt**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 2, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 3, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 4, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 5, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 6, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 8, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "cast([[fp + 28] + 2] - [ap + (-1)], felt)" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 1 + }, + "pc": 365, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 25, + "offset": 0 + }, + "pc": 380, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 25, + "offset": 0 + }, + "pc": 380, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 25, + "offset": 1 + }, + "pc": 387, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 25, + "offset": 2 + }, + "pc": 388, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 25, + "offset": 3 + }, + "pc": 389, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 1 + }, + "pc": 403, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 28, + "offset": 0 + }, + "pc": 410, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 28, + "offset": 0 + }, + "pc": 410, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 29, + "offset": 0 + }, + "pc": 416, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 29, + "offset": 0 + }, + "pc": 416, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 417, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 417, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 418, + "value": "cast([fp + (-4)] + 1, felt)" + }, + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 31, + "offset": 5 + }, + "pc": 425, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 5 + }, + "pc": 430, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 14 + }, + "pc": 434, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 1 + }, + "pc": 437, + "value": "[cast(fp, felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 20 + }, + "pc": 443, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 21 + }, + "pc": 444, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 22 + }, + "pc": 445, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 451, + "value": "[cast([fp + (-5)] + 2, felt*)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 451, + "value": "cast([fp + (-5)] + 3, starkware.cairo.common.cairo_builtins.HashBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 35, + "offset": 4 + }, + "pc": 459, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 35, + "offset": 4 + }, + "pc": 459, + "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" + }, + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-5), starkware.cairo.common.hash_state.HashState**)]" + }, + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 0 + }, + "pc": 473, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 0 + }, + "pc": 473, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 2 + }, + "pc": 475, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 2 + }, + "pc": 475, + "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 3 + }, + "pc": 477, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 38, + "offset": 0 + }, + "pc": 481, + "value": "[cast(fp + (-3), starkware.cairo.common.hash_state.HashState**)]" + }, + { + "ap_tracking_data": { + "group": 38, + "offset": 0 + }, + "pc": 481, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 38, + "offset": 7 + }, + "pc": 486, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 38, + "offset": 7 + }, + "pc": 486, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 496, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 497, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 497, + "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 5 + }, + "pc": 500, + "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 6 + }, + "pc": 501, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 7 + }, + "pc": 503, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 7 + }, + "pc": 504, + "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 10 + }, + "pc": 511, + "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 10 + }, + "pc": 511, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 40, + "offset": 7 + }, + "pc": 514, + "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 0 + }, + "pc": 520, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 0 + }, + "pc": 520, + "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 9 + }, + "pc": 522, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 2 + }, + "pc": 528, + "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 2 + }, + "pc": 528, + "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 529, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 530, + "value": "[cast(ap, felt*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 530, + "value": "cast(ap + 1, starkware.cairo.common.memcpy.memcpy.LoopFrame*)" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-11), felt**)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-8), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 11 + }, + "pc": 540, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 11 + }, + "pc": 540, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 552, + "value": "[cast(fp + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 553, + "value": "[cast(fp + 2, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 554, + "value": "[cast(fp + 3, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 555, + "value": "[cast(fp + 4, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 556, + "value": "[cast(fp + 5, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 557, + "value": "[cast(fp + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 558, + "value": "[cast(fp + 7, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 559, + "value": "[cast(fp + 8, felt**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 559, + "value": "[cast(fp + 9, __main__.BootloaderConfig**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 564, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 564, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast(fp + 10, felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast([ap + (-2)] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast([fp], felt*)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast([fp] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast(0, felt)" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-4), __main__.BootloaderConfig**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-10), felt**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-9), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 1 + }, + "pc": 603, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + }, + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 52, + "offset": 1 + }, + "pc": 632, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 638, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 638, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 639, + "value": "cast([fp + (-5)] + 2, felt*)" + }, + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "[cast(fp + (-3), __main__.TaskOutputHeader**)]" + }, + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "cast([fp + (-3)] + 2, felt*)" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 4 + }, + "pc": 649, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 4 + }, + "pc": 649, + "value": "[cast(fp + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 0 + }, + "pc": 654, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 0 + }, + "pc": 654, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 5 + }, + "pc": 657, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 5 + }, + "pc": 657, + "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 6 + }, + "pc": 659, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 37 + }, + "pc": 668, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 669, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 673, + "value": "[cast(fp + 2, felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "[cast(fp + 3, felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "[cast([fp], felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "cast([fp] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 698, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 698, + "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 699, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 8 + }, + "pc": 700, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 9 + }, + "pc": 702, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 9 + }, + "pc": 703, + "value": "cast([fp + (-9)] + 2, felt*)" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 10 + }, + "pc": 704, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 10 + }, + "pc": 706, + "value": "[cast(fp + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp + (-9)] + 2 + [fp + 1], felt*)" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp] + [fp + 1], felt*)" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp + (-5)] + 1, felt)" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 1 + }, + "pc": 714, + "value": "[cast(ap + (-1), felt*)]" + } + ] + } +} diff --git a/scripts/compile-bootloader.sh b/scripts/compile-bootloader.sh new file mode 100644 index 0000000..ada0b76 --- /dev/null +++ b/scripts/compile-bootloader.sh @@ -0,0 +1,32 @@ +#!/bin/bash +# Compiles the Cairo bootloader found in the cairo-lang submodule. +# The compiled bootloader is versioned to make compilation easier. This script is currently only used +# to recompile the bootloader when changing the version of cairo-lang. + +SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) +CAIRO_VERSION="0.13.1" + +CAIRO_LANG_DIR=$(readlink -f "${SCRIPT_DIR}/../dependencies/cairo-lang") + +if ! command -v cairo-compile >/dev/null; then + echo "please start cairo ($CAIRO_VERSION) dev environment" + exit 1 +fi + +echo -e "\ninitializing cairo-lang ($CAIRO_VERSION)...\n" +git submodule update --init + +FETCHED_CAIRO_VER="$(cat "${CAIRO_LANG_DIR}/src/starkware/cairo/lang/VERSION")" + +if [ "$CAIRO_VERSION" != "$FETCHED_CAIRO_VER" ]; then + echo "incorrect cairo ver($FETCHED_CAIRO_VER) expecting $CAIRO_VERSION" + exit 1 +fi + +OUTPUT_DIR="$(readlink -f "${SCRIPT_DIR}/../resources")" +mkdir -p "${OUTPUT_DIR}" +COMPILED_BOOTLOADER="${OUTPUT_DIR}/bootloader-${CAIRO_VERSION}.json" + +cairo-compile "${CAIRO_LANG_DIR}/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" --output "${COMPILED_BOOTLOADER}" --cairo_path "${CAIRO_LANG_DIR}"/src + +echo "Compiled the bootloader to '${COMPILED_BOOTLOADER}'." \ No newline at end of file diff --git a/src/hints/hint_processor.rs b/src/hints/hint_processor.rs index bb26763..141bb75 100644 --- a/src/hints/hint_processor.rs +++ b/src/hints/hint_processor.rs @@ -6,6 +6,7 @@ use cairo_vm::hint_processor::builtin_hint_processor::memcpy_hint_utils::exit_sc use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; use cairo_vm::types::exec_scope::ExecutionScopes; use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::runners::cairo_runner::ResourceTracker; use cairo_vm::vm::vm_core::VirtualMachine; use cairo_vm::Felt252; @@ -31,6 +32,12 @@ use crate::hints::simple_bootloader_hints::{ pub struct BootloaderHintProcessor; +impl BootloaderHintProcessor { + pub fn new() -> Self { + Self {} + } +} + impl HintProcessorLogic for BootloaderHintProcessor { fn execute_hint( &mut self, @@ -113,3 +120,5 @@ impl HintProcessorLogic for BootloaderHintProcessor { } } } + +impl ResourceTracker for BootloaderHintProcessor {} diff --git a/src/hints/mod.rs b/src/hints/mod.rs index 4cc0bd7..baede92 100644 --- a/src/hints/mod.rs +++ b/src/hints/mod.rs @@ -13,4 +13,8 @@ mod types; mod vars; pub use hint_processor::BootloaderHintProcessor; -pub use types::{SimpleBootloaderInput, Task, TaskSpec}; +pub use types::{ + BootloaderConfig, BootloaderInput, PackedOutput, SimpleBootloaderInput, Task, TaskSpec, +}; + +pub use vars::BOOTLOADER_INPUT; diff --git a/src/hints/vars.rs b/src/hints/vars.rs index 92a8514..dd25c27 100644 --- a/src/hints/vars.rs +++ b/src/hints/vars.rs @@ -1,47 +1,47 @@ /// Deserialized bootloader input. -pub(crate) const BOOTLOADER_INPUT: &str = "bootloader_input"; +pub const BOOTLOADER_INPUT: &str = "bootloader_input"; /// The bootloader program, as a Program object. -pub(crate) const BOOTLOADER_PROGRAM_IDENTIFIERS: &str = "bootloader_program"; +pub const BOOTLOADER_PROGRAM_IDENTIFIERS: &str = "bootloader_program"; /// Saved state of the output builtin. -pub(crate) const OUTPUT_BUILTIN_STATE: &str = "output_builtin_state"; +pub const OUTPUT_BUILTIN_STATE: &str = "output_builtin_state"; /// Output builtin segment start. -pub(crate) const OUTPUT_START: &str = "output_start"; +pub const OUTPUT_START: &str = "output_start"; /// Deserialized simple bootloader input. -pub(crate) const SIMPLE_BOOTLOADER_INPUT: &str = "simple_bootloader_input"; +pub const SIMPLE_BOOTLOADER_INPUT: &str = "simple_bootloader_input"; /// Packed outputs. -pub(crate) const PACKED_OUTPUTS: &str = "packed_outputs"; +pub const PACKED_OUTPUTS: &str = "packed_outputs"; /// Packed output for the current task. -pub(crate) const PACKED_OUTPUT: &str = "packed_output"; +pub const PACKED_OUTPUT: &str = "packed_output"; /// Fact topologies. -pub(crate) const FACT_TOPOLOGIES: &str = "fact_topologies"; +pub const FACT_TOPOLOGIES: &str = "fact_topologies"; /// Simple bootloader tasks. -pub(crate) const TASKS: &str = "tasks"; +pub const TASKS: &str = "tasks"; /// Current simple bootloader task. -pub(crate) const TASK: &str = "task"; +pub const TASK: &str = "task"; /// Program data segment. Used in `execute_task()`. -pub(crate) const PROGRAM_DATA_BASE: &str = "program_data_base"; +pub const PROGRAM_DATA_BASE: &str = "program_data_base"; /// Address of current program. -pub(crate) const PROGRAM_ADDRESS: &str = "program_address"; +pub const PROGRAM_ADDRESS: &str = "program_address"; /// Output builtin additional data. -pub(crate) const OUTPUT_RUNNER_DATA: &str = "output_runner_data"; +pub const OUTPUT_RUNNER_DATA: &str = "output_runner_data"; /// Number of builtins used by the program. -pub(crate) const N_BUILTINS: &str = "n_builtins"; +pub const N_BUILTINS: &str = "n_builtins"; /// Number of selected builtins for the current program. -pub(crate) const N_SELECTED_BUILTINS: &str = "n_selected_builtins"; +pub const N_SELECTED_BUILTINS: &str = "n_selected_builtins"; /// "pre_execution_builtin_ptrs" -pub(crate) const PRE_EXECUTION_BUILTIN_PTRS: &str = "pre_execution_builtin_ptrs"; +pub const PRE_EXECUTION_BUILTIN_PTRS: &str = "pre_execution_builtin_ptrs"; diff --git a/src/lib.rs b/src/lib.rs index 8f2c85f..efe4d48 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,3 +1,22 @@ pub mod hints; +pub mod tasks; +use cairo_vm::types::errors::program_errors::ProgramError; +use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::types::program::Program; pub use hints::*; + +const BOOTLOADER_V0_13_1: &[u8] = include_bytes!("../resources/bootloader-0.13.1.json"); + +/// Loads the bootloader and returns it as a Cairo VM `Program` object. +pub fn load_bootloader() -> Result { + Program::from_bytes(BOOTLOADER_V0_13_1, Some("main")) +} + +/// Inserts the bootloader input in the execution scopes. +pub fn insert_bootloader_input( + exec_scopes: &mut ExecutionScopes, + bootloader_input: BootloaderInput, +) { + exec_scopes.insert_value(BOOTLOADER_INPUT, bootloader_input); +} diff --git a/src/tasks.rs b/src/tasks.rs new file mode 100644 index 0000000..1cd290d --- /dev/null +++ b/src/tasks.rs @@ -0,0 +1,38 @@ +use cairo_vm::types::errors::program_errors::ProgramError; +use cairo_vm::types::program::Program; +use cairo_vm::vm::runners::cairo_pie::CairoPie; + +use crate::{Task, TaskSpec}; + +#[derive(thiserror::Error, Debug)] +pub enum BootloaderTaskError { + #[error("Failed to read program: {0}")] + Program(#[from] ProgramError), + + #[error("Failed to read PIE: {0}")] + Pie(#[from] std::io::Error), +} + +pub fn make_bootloader_tasks( + programs: &[&[u8]], + pies: &[&[u8]], +) -> Result, BootloaderTaskError> { + let program_tasks = programs.iter().map(|program_bytes| { + let program = Program::from_bytes(program_bytes, Some("main")); + program + .map(|program| TaskSpec { + task: Task::Program(program), + }) + .map_err(BootloaderTaskError::Program) + }); + + let cairo_pie_tasks = pies.iter().map(|pie_bytes| { + let pie = CairoPie::from_bytes(pie_bytes); + pie.map(|pie| TaskSpec { + task: Task::Pie(pie), + }) + .map_err(BootloaderTaskError::Pie) + }); + + program_tasks.chain(cairo_pie_tasks).collect() +} From 4935a4a8ddf05cb6e88873e642e3afc0820e0494 Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Fri, 24 May 2024 15:38:23 +0200 Subject: [PATCH 05/28] example comments --- examples/run_program.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/examples/run_program.rs b/examples/run_program.rs index 3e375c9..83c65d4 100644 --- a/examples/run_program.rs +++ b/examples/run_program.rs @@ -97,6 +97,7 @@ fn cairo_run_bootloader_in_proof_mode( allow_missing_builtins: None, }; + // Build the bootloader input let n_tasks = tasks.len(); let bootloader_input = BootloaderInput { simple_bootloader_input: SimpleBootloaderInput { @@ -116,6 +117,7 @@ fn cairo_run_bootloader_in_proof_mode( let mut exec_scopes = ExecutionScopes::new(); insert_bootloader_input(&mut exec_scopes, bootloader_input); + // Run the bootloader cairo_run_program( &bootloader_program, &cairo_run_config, From fb2312f0f9bda782d4d08e8c6bb0bdf77f904ed8 Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Fri, 24 May 2024 15:40:11 +0200 Subject: [PATCH 06/28] example of fix --- src/hints/bootloader_hints.rs | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/src/hints/bootloader_hints.rs b/src/hints/bootloader_hints.rs index d54482a..b03af4b 100644 --- a/src/hints/bootloader_hints.rs +++ b/src/hints/bootloader_hints.rs @@ -437,7 +437,9 @@ mod tests { use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_maybe_relocatable_from_var_name; use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; use cairo_vm::serde::deserialize_program::OffsetValue; - use cairo_vm::vm::runners::builtin_runner::{BuiltinRunner, OutputBuiltinState}; + use cairo_vm::vm::runners::builtin_runner::{ + BuiltinRunner, OutputBuiltinRunner, OutputBuiltinState, + }; use cairo_vm::vm::runners::cairo_pie::PublicMemoryPage; use cairo_vm::{any_box, relocatable, Felt252}; use rstest::{fixture, rstest}; @@ -465,9 +467,10 @@ mod tests { #[rstest] fn test_prepare_simple_bootloader_output_segment(bootloader_input: BootloaderInput) { - let mut vm = vm!(); - vm.segments.add(); - vm.run_context.fp = 1; + let mut vm = VirtualMachine::new(false); + vm.add_memory_segment(); + vm.add_memory_segment(); + vm.set_fp(1); let mut output_builtin = OutputBuiltinRunner::new(true); output_builtin.initialize_segments(&mut vm.segments); @@ -475,7 +478,10 @@ mod tests { .push(BuiltinRunner::Output(output_builtin.clone())); let mut exec_scopes = ExecutionScopes::new(); - let ids_data = ids_data!["simple_bootloader_output_start"]; + let ids_data = HashMap::from([( + "simple_bootloader_output_start".to_string(), + HintReference::new_simple(-1), + )]); let ap_tracking = ApTracking::new(); exec_scopes.insert_value(vars::BOOTLOADER_INPUT, bootloader_input); @@ -498,8 +504,6 @@ mod tests { // Check the content of the stored output builtin assert_ne!(current_output_builtin.base(), stored_output_builtin.base()); assert_eq!(stored_output_builtin.base(), output_builtin.base()); - assert_eq!(stored_output_builtin.stop_ptr, output_builtin.stop_ptr); - assert_eq!(stored_output_builtin.included, output_builtin.included); let simple_bootloader_output_start = get_maybe_relocatable_from_var_name( "simple_bootloader_output_start", From 179a1a1696a7dd71aa54b770efe696c84a5e2b71 Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Wed, 22 May 2024 14:38:13 +0200 Subject: [PATCH 07/28] Feature: bootloader hint processor Problem: Starkware devs want to use the bootloader with upstream cairo-vm for their own use case. Solution: migrate all hints from our fork of `cairo-vm` and add a `BootloaderHintProcessor` struct that users can then import and add to their own hint processing logic. Limitations: * the tests do not work yet, we need to modify test code that relies on internal cairo-vm test macros. * the bootloader is not yet compiled and provided as part of the library. --- Cargo.toml | 5 +- dependencies/cairo-lang | 2 +- src/hints/hint_processor.rs | 115 ++++++++++++++++++++++++++++++++++++ 3 files changed, 119 insertions(+), 3 deletions(-) create mode 100644 src/hints/hint_processor.rs diff --git a/Cargo.toml b/Cargo.toml index 72862d1..37c32d6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,7 +6,9 @@ edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -cairo-vm = { git = "https://github.com/lambdaclass/cairo-vm", rev = "05352b1c67859a4d8cd128575c1e68ca7e300341", features = ["extensive_hints"] } +cairo-vm = { git = "https://github.com/lambdaclass/cairo-vm", rev = "05352b1c67859a4d8cd128575c1e68ca7e300341", features = [ + "extensive_hints", +] } num-traits = "0.2.19" serde = { version = "1.0.202", features = ["derive"] } serde_json = "1.0.117" @@ -18,4 +20,3 @@ thiserror-no-std = "2.0.2" [dev-dependencies] assert_matches = "1.5.0" rstest = "0.19.0" - diff --git a/dependencies/cairo-lang b/dependencies/cairo-lang index caba294..efa9648 160000 --- a/dependencies/cairo-lang +++ b/dependencies/cairo-lang @@ -1 +1 @@ -Subproject commit caba294d82eeeccc3d86a158adb8ba209bf2d8fc +Subproject commit efa9648f57568aad8f8a13fbf027d2de7c63c2c0 diff --git a/src/hints/hint_processor.rs b/src/hints/hint_processor.rs new file mode 100644 index 0000000..bb26763 --- /dev/null +++ b/src/hints/hint_processor.rs @@ -0,0 +1,115 @@ +use std::any::Any; +use std::collections::HashMap; + +use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData; +use cairo_vm::hint_processor::builtin_hint_processor::memcpy_hint_utils::exit_scope; +use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; +use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::vm_core::VirtualMachine; +use cairo_vm::Felt252; + +use crate::hints::bootloader_hints::{ + assert_is_composite_packed_output, assert_program_address, + compute_and_configure_fact_topologies, enter_packed_output_scope, + guess_pre_image_of_subtasks_output_hash, import_packed_output_schemas, is_plain_packed_output, + load_bootloader_config, prepare_simple_bootloader_input, + prepare_simple_bootloader_output_segment, restore_bootloader_output, save_output_pointer, + save_packed_outputs, set_packed_output_to_subtasks, +}; +use crate::hints::codes::*; +use crate::hints::execute_task_hints::{ + allocate_program_data_segment, append_fact_topologies, call_task, load_program_hint, + validate_hash, write_return_builtins_hint, +}; +use crate::hints::inner_select_builtins::select_builtin; +use crate::hints::select_builtins::select_builtins_enter_scope; +use crate::hints::simple_bootloader_hints::{ + divide_num_by_2, prepare_task_range_checks, set_ap_to_zero, set_current_task, + set_tasks_variable, +}; + +pub struct BootloaderHintProcessor; + +impl HintProcessorLogic for BootloaderHintProcessor { + fn execute_hint( + &mut self, + vm: &mut VirtualMachine, + exec_scopes: &mut ExecutionScopes, + hint_data: &Box, + _constants: &HashMap, + ) -> Result<(), HintError> { + let hint_data = hint_data + .downcast_ref::() + .ok_or(HintError::WrongHintData)?; + + let ids_data = &hint_data.ids_data; + let ap_tracking = &hint_data.ap_tracking; + + match hint_data.code.as_str() { + BOOTLOADER_RESTORE_BOOTLOADER_OUTPUT => restore_bootloader_output(vm, exec_scopes), + BOOTLOADER_PREPARE_SIMPLE_BOOTLOADER_INPUT => { + prepare_simple_bootloader_input(exec_scopes) + } + BOOTLOADER_LOAD_BOOTLOADER_CONFIG => { + load_bootloader_config(vm, exec_scopes, ids_data, ap_tracking) + } + BOOTLOADER_ENTER_PACKED_OUTPUT_SCOPE => { + enter_packed_output_scope(vm, exec_scopes, ids_data, ap_tracking) + } + BOOTLOADER_SAVE_OUTPUT_POINTER => { + save_output_pointer(vm, exec_scopes, ids_data, ap_tracking) + } + BOOTLOADER_SAVE_PACKED_OUTPUTS => save_packed_outputs(exec_scopes), + BOOTLOADER_GUESS_PRE_IMAGE_OF_SUBTASKS_OUTPUT_HASH => { + guess_pre_image_of_subtasks_output_hash(vm, exec_scopes, ids_data, ap_tracking) + } + BOOTLOADER_PREPARE_SIMPLE_BOOTLOADER_OUTPUT_SEGMENT => { + prepare_simple_bootloader_output_segment(vm, exec_scopes, ids_data, ap_tracking) + } + BOOTLOADER_COMPUTE_FACT_TOPOLOGIES => { + compute_and_configure_fact_topologies(vm, exec_scopes) + } + BOOTLOADER_SET_PACKED_OUTPUT_TO_SUBTASKS => set_packed_output_to_subtasks(exec_scopes), + BOOTLOADER_IMPORT_PACKED_OUTPUT_SCHEMAS => import_packed_output_schemas(), + BOOTLOADER_IS_PLAIN_PACKED_OUTPUT => is_plain_packed_output(vm, exec_scopes), + BOOTLOADER_ASSERT_IS_COMPOSITE_PACKED_OUTPUT => { + assert_is_composite_packed_output(exec_scopes) + } + SIMPLE_BOOTLOADER_PREPARE_TASK_RANGE_CHECKS => { + prepare_task_range_checks(vm, exec_scopes, ids_data, ap_tracking) + } + SIMPLE_BOOTLOADER_SET_TASKS_VARIABLE => set_tasks_variable(exec_scopes), + SIMPLE_BOOTLOADER_DIVIDE_NUM_BY_2 => divide_num_by_2(vm, ids_data, ap_tracking), + SIMPLE_BOOTLOADER_SET_CURRENT_TASK => { + set_current_task(vm, exec_scopes, ids_data, ap_tracking) + } + SIMPLE_BOOTLOADER_ZERO => set_ap_to_zero(vm), + EXECUTE_TASK_ALLOCATE_PROGRAM_DATA_SEGMENT => { + allocate_program_data_segment(vm, exec_scopes, ids_data, ap_tracking) + } + EXECUTE_TASK_LOAD_PROGRAM => load_program_hint(vm, exec_scopes, ids_data, ap_tracking), + EXECUTE_TASK_VALIDATE_HASH => validate_hash(vm, exec_scopes, ids_data, ap_tracking), + EXECUTE_TASK_ASSERT_PROGRAM_ADDRESS => { + assert_program_address(vm, exec_scopes, ids_data, ap_tracking) + } + EXECUTE_TASK_CALL_TASK => call_task(vm, exec_scopes, ids_data, ap_tracking), + EXECUTE_TASK_WRITE_RETURN_BUILTINS => { + write_return_builtins_hint(vm, exec_scopes, ids_data, ap_tracking) + } + EXECUTE_TASK_EXIT_SCOPE => exit_scope(exec_scopes), + EXECUTE_TASK_APPEND_FACT_TOPOLOGIES => { + append_fact_topologies(vm, exec_scopes, ids_data, ap_tracking) + } + SELECT_BUILTINS_ENTER_SCOPE => { + select_builtins_enter_scope(vm, exec_scopes, ids_data, ap_tracking) + } + INNER_SELECT_BUILTINS_SELECT_BUILTIN => { + select_builtin(vm, exec_scopes, ids_data, ap_tracking) + } + unknown_hint_code => Err(HintError::UnknownHint( + unknown_hint_code.to_string().into_boxed_str(), + )), + } + } +} From c7a440e1a8ff159458e6b2744e35302c067f9d31 Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Fri, 24 May 2024 14:59:28 +0200 Subject: [PATCH 08/28] add bootloader --- resources/bootloader-0.13.1.json | 35810 +++++++++++++++++++++++++++++ src/hints/hint_processor.rs | 9 + src/lib.rs | 3 + 3 files changed, 35822 insertions(+) create mode 100644 resources/bootloader-0.13.1.json diff --git a/resources/bootloader-0.13.1.json b/resources/bootloader-0.13.1.json new file mode 100644 index 0000000..517ab31 --- /dev/null +++ b/resources/bootloader-0.13.1.json @@ -0,0 +1,35810 @@ +{ + "attributes": [], + "builtins": [ + "output", + "pedersen", + "range_check", + "ecdsa", + "bitwise", + "ec_op", + "keccak", + "poseidon", + "range_check96" + ], + "compiler_version": "0.13.0", + "data": [ + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x482480017ffe8000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffff", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x4", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0x404b800080008000", + "0x400380007ff98001", + "0x400380007ffa8002", + "0x20780017fff8000", + "0x4", + "0x10780017fff7fff", + "0x4", + "0x400380007ffb8001", + "0x400380007ffc8002", + "0x482680017ff98000", + "0x1", + "0x482680017ffa8000", + "0x1", + "0x482a80007ffb8000", + "0x482a80007ffc8000", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffea", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe1", + "0x484680017ffb8000", + "0xa", + "0x482480017fff8000", + "0xc", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffc7fff8000", + "0x48307ffc7ff98000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffdc", + "0x402a7ffc7ffd7fff", + "0x40b7ffd7fff7fff", + "0x208b7fff7fff7ffe", + "0x48297ffb80007ffc", + "0x48487ffd80007fff", + "0x400280007ffa7fff", + "0x482680017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x4", + "0x480a7ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff97fff8000", + "0x480280007ffa8000", + "0x480280007ffb8000", + "0x480280007ffc8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff3", + "0x482680017ffa8000", + "0x1", + "0x482680017ffb8000", + "0x1", + "0x482680017ffc8000", + "0x1", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffef", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480a7ffd7fff8000", + "0x480a7ffb7fff8000", + "0x40780017fff7fff", + "0x1", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x3a", + "0x480080007ffd8000", + "0x48307fff7ff98000", + "0x400080007ffc7fff", + "0x480080017ffb8000", + "0x48307fff7ff88000", + "0x400080017ffa7fff", + "0x400080027ffa7ff8", + "0x480080037ffa8000", + "0x480080027ff88000", + "0x48307fff7ffe8000", + "0x400080067ff77fff", + "0x480080047ff78000", + "0x480080037ff58000", + "0x48307fff7ffe8000", + "0x400080077ff47fff", + "0x480080057ff48000", + "0x400080087ff37fff", + "0x480080097ff38000", + "0x480080047ff18000", + "0x48307fff7ffe8000", + "0x4000800c7ff07fff", + "0x4800800a7ff08000", + "0x480080057fee8000", + "0x48307fff7ffe8000", + "0x4000800d7fed7fff", + "0x4800800b7fed8000", + "0x4000800e7fec7fff", + "0x4800800f7fec8000", + "0x480080067fea8000", + "0x48307fff7ffe8000", + "0x400080127fe97fff", + "0x480080107fe98000", + "0x480080077fe78000", + "0x48307fff7ffe8000", + "0x400080137fe67fff", + "0x480080117fe68000", + "0x400080147fe57fff", + "0x480080157fe58000", + "0x480080087fe38000", + "0x48307fff7ffe8000", + "0x400080187fe27fff", + "0x480080167fe28000", + "0x480080097fe08000", + "0x48307fff7ffe8000", + "0x400080197fdf7fff", + "0x480080177fdf8000", + "0x4000801a7fde7fff", + "0x4800801b7fde8000", + "0x4800801c7fdd8000", + "0x4800801d7fdc8000", + "0x482480017fda8000", + "0xa", + "0x482480017fda8000", + "0x1e", + "0x10780017fff7fff", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc5", + "0x40780017fff7fff", + "0x1", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x12", + "0x480080007ffc8000", + "0x48307fff7ff88000", + "0x400080007ffb7fff", + "0x480080017ffa8000", + "0x48307fff7ff78000", + "0x400080017ff97fff", + "0x400080027ff97ff7", + "0x480080037ff98000", + "0x480080047ff88000", + "0x480080057ff78000", + "0x482480017ff58000", + "0x2", + "0x482480017ff58000", + "0x6", + "0x10780017fff7fff", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffaf", + "0x482a7ffc7ffd8000", + "0x48307ffb80007fff", + "0x20680017fff7fff", + "0xb", + "0x482480017ff78000", + "0x1", + "0x400080007ffa7fff", + "0x400080017ffa7ff7", + "0x400080027ffa7ff8", + "0x482480017ffa8000", + "0x6", + "0x480080037ff98000", + "0x208b7fff7fff7ffe", + "0x400680017fff7fff", + "0x1", + "0x480080007ffa8000", + "0x48307fff7ff68000", + "0x400080007ff97fff", + "0x482480017ff68000", + "0x1", + "0x400080017ff87fff", + "0x400080027ff87ff6", + "0x482480017ff88000", + "0x6", + "0x480080037ff78000", + "0x208b7fff7fff7ffe", + "0x480280007ffd8000", + "0x48327fff7ffd8000", + "0x480a7ffc7fff8000", + "0x480080007ffe8000", + "0x48007fff7ffd8000", + "0x480080007ffd7fff", + "0x400080017ffc7ffd", + "0x482480017ffb8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x482480017ffb8000", + "0x3", + "0x480080027ffa8000", + "0x40287ffd7ffc7ffd", + "0x20680017fff7ffc", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff8", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x20680017fff7fff", + "0xc", + "0x480a7ffb7fff8000", + "0x480280007ffc8000", + "0x482680017ffc8000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff73", + "0x480a7ffa7fff8000", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1a", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff18", + "0x40137ffe7fff8000", + "0x400380007ff98002", + "0x480680017fff8000", + "0x0", + "0x4002800180017fff", + "0x480280017ff98000", + "0x480280077ff98000", + "0x480a80017fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffde", + "0x4002800180027fff", + "0x4027800180018003", + "0x4", + "0x4003800380018004", + "0x482a800480038000", + "0x4802800280018000", + "0x40317fff7ffe8005", + "0x4027800180028006", + "0x2", + "0x40137ffb7fff8007", + "0x400380027ff98008", + "0x400380037ff98009", + "0x400380047ff9800a", + "0x400380057ff9800b", + "0x400380067ff9800c", + "0x40137ffc7fff800d", + "0x400380087ff9800e", + "0x480a7ffb7fff8000", + "0x4826800180008000", + "0x6", + "0x480680017fff8000", + "0x9", + "0x480a80037fff8000", + "0x480a80047fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff13", + "0x1088800580018000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffef1", + "0x402a8004800f7fff", + "0x480a7ffb7fff8000", + "0x4826800180008000", + "0x10", + "0x480a80037fff8000", + "0x480a800f7fff8000", + "0x480680017fff8000", + "0x9", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffeec", + "0x402a800380047fff", + "0x480a7ffa7fff8000", + "0x4826800180008000", + "0x6", + "0x4826800180008000", + "0x10", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x9", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff11", + "0x402b800280198010", + "0x4003800080028019", + "0x4826800180008000", + "0x10", + "0x48127ffe7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1d", + "0x402780017ff58001", + "0x1", + "0x400b7ff67fff8002", + "0x400b80007fff8003", + "0x400b7ff87fff8004", + "0x400b7ff97fff8005", + "0x400b7ffa7fff8006", + "0x400b7ffb7fff8007", + "0x400b7ffc7fff8008", + "0x400b7ffd7fff8009", + "0x400780017fff800a", + "0x6f7574707574", + "0x400780017fff800b", + "0x706564657273656e", + "0x400780017fff800c", + "0x72616e67655f636865636b", + "0x400780017fff800d", + "0x6563647361", + "0x400780017fff800e", + "0x62697477697365", + "0x400780017fff800f", + "0x65635f6f70", + "0x400780017fff8010", + "0x6b656363616b", + "0x400780017fff8011", + "0x706f736569646f6e", + "0x400780017fff8012", + "0x72616e67655f636865636b3936", + "0x400780017fff8013", + "0x1", + "0x400780017fff8014", + "0x3", + "0x400780017fff8015", + "0x1", + "0x400780017fff8016", + "0x2", + "0x400780017fff8017", + "0x5", + "0x400780017fff8018", + "0x7", + "0x400780017fff8019", + "0x10", + "0x400780017fff801a", + "0x6", + "0x400780017fff801b", + "0x1", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffea3", + "0x482480017ffe8000", + "0x1", + "0x480a7ff77fff8000", + "0x482480017ffc8000", + "0xa", + "0x482480017ffb8000", + "0x13", + "0x480280007ff58000", + "0x1104800180018000", + "0x24", + "0x400a80007fff7fff", + "0x40137ffe7fff801c", + "0x48028002801c8000", + "0x48307ffe80007fff", + "0x480680017fff8000", + "0x40", + "0x1104800180018000", + "0xc", + "0x48028000801c8000", + "0x48028001801c8000", + "0x48028002801c8000", + "0x48028003801c8000", + "0x48028004801c8000", + "0x48028005801c8000", + "0x48028006801c8000", + "0x48028007801c8000", + "0x48028008801c8000", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x5", + "0x400780017fff7ffc", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x48307fff7fff8000", + "0x48317fff80007ffc", + "0x40507fff7fff7fff", + "0x48127ffd7fff8000", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff4", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x5", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x48127ffb7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff50", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffef", + "0x208b7fff7fff7ffe", + "0x400380007ffc7ffd", + "0x482680017ffc8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x48297ffc80007ffd", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffb", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff6", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff6", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480a7ff97fff8000", + "0x480a80007fff8000", + "0x482680017ffc8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff2", + "0x484a80007ffb8000", + "0x48327fff7ffa8000", + "0x400180007fff7ffd", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x208b7fff7fff7ffe", + "0x400380007ffb7ffc", + "0x400380017ffb7ffd", + "0x482680017ffb8000", + "0x3", + "0x480280027ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe38", + "0x400780017fff8000", + "0x0", + "0x400780017fff8001", + "0x0", + "0x48127ffe7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x480a7ffa7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480280007ffb8000", + "0x1104800180018000", + "0x10", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe28", + "0x40137ffd7fff8000", + "0x480280017ffb8000", + "0x40297ffd7fff8001", + "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffde", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffc", + "0x5", + "0x480a7ffa7fff8000", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x482680017ffc8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x40337fff7ffb8000", + "0x480a7ffb7fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffd7fff8000", + "0x48317ffd80008000", + "0x400080007ffd7ffe", + "0x480080007ffc8000", + "0x400080017ffc7fff", + "0x482480017ffb8000", + "0x1", + "0x482480017ffb8000", + "0x3", + "0x480080027ffa8000", + "0x20680017fff7ffb", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff8", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc8", + "0x480a7ffb7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffcc", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffda", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x3", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480080007fff8000", + "0x400080007ffd7fff", + "0x482480017ffd8001", + "0x1", + "0x482480017ffd8001", + "0x1", + "0xa0680017fff7ffe", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffb", + "0x402a7ffc7ffd7fff", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xb", + "0x480a80007fff8000", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff0a", + "0x40137ff97fff8001", + "0x40137ffa7fff8002", + "0x40137ffb7fff8003", + "0x40137ffc7fff8004", + "0x40137ffd7fff8005", + "0x40137ffe7fff8006", + "0x40137fff7fff8007", + "0x40137ff77fff8008", + "0x480a7ff57fff8000", + "0x48127ff77fff8000", + "0x480a80097fff8000", + "0x1104800180018000", + "0x45", + "0x40137ffe7fff800a", + "0x482480017ffe8000", + "0x1", + "0x48127ffe7fff8000", + "0x480a80067fff8000", + "0x480a80017fff8000", + "0x480680017fff8000", + "0x0", + "0x4826800180008000", + "0x1", + "0x480a80097fff8000", + "0x4802800080008000", + "0x1104800180018000", + "0xe", + "0x40137fff7fff8008", + "0x40028000800a7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffb7fff8000", + "0x480a80027fff8000", + "0x480a80037fff8000", + "0x480a80047fff8000", + "0x480a80057fff8000", + "0x48127ff57fff8000", + "0x480a80077fff8000", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x9", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x0", + "0x40780017fff7fff", + "0x1", + "0x20680017fff7fff", + "0xd", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x23", + "0x10780017fff7fff", + "0xb", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x46", + "0x480a7ffc7fff8000", + "0x482680017ffd8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffdb", + "0x208b7fff7fff7ffe", + "0x480280007ffd8000", + "0x400280007ffb7fff", + "0x480a7ffc7fff8000", + "0x480280027ffd8000", + "0x480280017ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff85", + "0x400280017ffb7fff", + "0x482680017ffb8000", + "0x2", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x2", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x4", + "0x480a7ff97fff8000", + "0x480a80017fff8000", + "0x480a80007fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffdc0", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff5", + "0x480680017fff8000", + "0x4", + "0x400080007ffe7fff", + "0x480a7ffa7fff8000", + "0x480280027ffd8000", + "0x480680017fff8000", + "0x1", + "0x480280017ffd8000", + "0x480080017ffa8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff1a", + "0x480280007ffd8000", + "0x400080007fdd7fff", + "0x400080017fdd7fd9", + "0x402580017fdd8002", + "0x2", + "0x400b80007fff8003", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x48127fd67fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x4802800080008000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffa4", + "0x402a800180037fff", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480a80027fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffcc", + "0x40137ffe7fff8000", + "0x480080007fff8000", + "0x400280007ff77fff", + "0x480080017ffe8000", + "0x400280017ff77fff", + "0x480080007ffd8000", + "0x402580017fff8001", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffff", + "0x482680017ff78000", + "0x2", + "0x480a80007fff8000", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff46", + "0x482680017ff78000", + "0x2", + "0x482880017fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x482680017ffb8000", + "0x1", + "0x482a800180008000", + "0x208b7fff7fff7ffe" + ], + "debug_info": { + "file_contents": {}, + "instruction_locations": { + "0": { + "accessible_scopes": [ + "starkware.cairo.lang.compiler.lib.registers", + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 0, + "offset": 0 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 7, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" + }, + "start_col": 5, + "start_line": 7 + } + }, + "1": { + "accessible_scopes": [ + "starkware.cairo.lang.compiler.lib.registers", + "starkware.cairo.lang.compiler.lib.registers.get_ap" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 0 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" + }, + "start_col": 28, + "start_line": 16 + } + }, + "3": { + "accessible_scopes": [ + "starkware.cairo.lang.compiler.lib.registers", + "starkware.cairo.lang.compiler.lib.registers.get_ap" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val": 0, + "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val": 1 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" + }, + "start_col": 20, + "start_line": 17 + } + }, + "5": { + "accessible_scopes": [ + "starkware.cairo.lang.compiler.lib.registers", + "starkware.cairo.lang.compiler.lib.registers.get_ap" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 1, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val": 0, + "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val": 1 + } + }, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" + }, + "start_col": 5, + "start_line": 17 + } + }, + "6": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 30, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 30 + } + }, + "8": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 40, + "start_line": 32 + }, + "While expanding the reference 'selected_encodings' in:" + ], + "start_col": 5, + "start_line": 21 + } + }, + "9": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 9, + "start_line": 32 + } + }, + "10": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 35 + } + }, + "12": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 46, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 38 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 53, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 48 + } + }, + "13": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 50, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 50 + } + }, + "14": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 51, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 51 + } + }, + "15": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 53 + } + }, + "17": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 53 + } + }, + "19": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 56, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 9, + "start_line": 56 + } + }, + "20": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 58, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 9, + "start_line": 58 + } + }, + "21": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 23, + "start_line": 65 + } + }, + "23": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 18, + "start_line": 66 + } + }, + "25": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 28, + "start_line": 67 + } + }, + "26": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 68, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 23, + "start_line": 68 + } + }, + "27": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 69, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 20, + "start_line": 69 + } + }, + "29": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 12, + "start_line": 64 + } + }, + "31": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 3, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" + }, + "start_col": 5, + "start_line": 64 + } + }, + "32": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 23, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 17, + "start_line": 23 + } + }, + "34": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [ + { + "location": { + "end_col": 75, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 5, + "start_line": 26 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 77, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 25, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 23, + "start_line": 31 + }, + "While expanding the reference 'selected_ptrs' in:" + ], + "start_col": 40, + "start_line": 25 + }, + "While expanding the reference 'total_func_memory' in:" + ], + "start_col": 29, + "start_line": 21 + }, + "While expanding the reference 'inner_func_memory' in:" + ], + "start_col": 29, + "start_line": 19 + } + }, + "36": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 25, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 23, + "start_line": 31 + }, + "While expanding the reference 'selected_ptrs' in:" + ], + "start_col": 40, + "start_line": 25 + }, + "While expanding the reference 'total_func_memory' in:" + ], + "start_col": 29, + "start_line": 21 + } + }, + "38": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 7, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 23, + "start_line": 28 + }, + "While expanding the reference 'all_encodings' in:" + ], + "start_col": 5, + "start_line": 7 + } + }, + "39": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 8, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 18, + "start_line": 29 + }, + "While expanding the reference 'all_ptrs' in:" + ], + "start_col": 5, + "start_line": 8 + } + }, + "40": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 10, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 30, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 28, + "start_line": 30 + }, + "While expanding the reference 'selected_encodings' in:" + ], + "start_col": 5, + "start_line": 10 + } + }, + "41": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 25, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 23, + "start_line": 31 + }, + "While expanding the reference 'selected_ptrs' in:" + ], + "start_col": 25, + "start_line": 25 + } + }, + "42": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 20, + "start_line": 32 + }, + "While expanding the reference 'n_all_builtins' in:" + ], + "start_col": 5, + "start_line": 9 + } + }, + "43": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 33, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 21, + "start_line": 27 + } + }, + "45": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 5, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [ + { + "location": { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 5, + "start_line": 34 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 80, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 5, + "start_line": 36 + } + }, + "46": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 5, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 38, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 5, + "start_line": 38 + } + }, + "47": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 6, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + }, + "hints": [], + "inst": { + "end_col": 8, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" + }, + "start_col": 5, + "start_line": 39 + } + }, + "48": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 25 + } + }, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 20, + "start_line": 16 + } + }, + "49": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 25 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 23, + "start_line": 17 + } + }, + "50": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": 27, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 25 + } + }, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 18 + } + }, + "51": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": 27, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 28 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 11, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 20, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 20 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 23, + "start_line": 11 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 27, + "start_line": 19 + } + }, + "53": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 7, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": 27, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 28 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 20, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 20 + } + }, + "54": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 40, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 40 + } + }, + "56": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 9, + "start_line": 41 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 37 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 37 + } + }, + "57": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 9, + "start_line": 41 + } + }, + "58": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 11, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 44 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 23, + "start_line": 11 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 37 + } + }, + "59": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 26, + "start_line": 45 + } + }, + "60": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 46, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 25, + "start_line": 46 + } + }, + "61": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 31, + "start_line": 47 + } + }, + "62": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "64": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 + } + }, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 51, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 27, + "start_line": 51 + } + }, + "66": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 52, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 26, + "start_line": 52 + } + }, + "68": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 + } + }, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 32, + "start_line": 53 + } + }, + "70": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 20, + "start_line": 54 + } + }, + "72": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 13 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 12, + "start_line": 50 + } + }, + "74": { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.validate_builtins", + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 9, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 35 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" + }, + "start_col": 5, + "start_line": 50 + } + }, + "75": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 45, + "start_line": 34 + } + }, + "77": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38 + } + }, + "hints": [], + "inst": { + "end_col": 52, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 51, + "start_line": 34 + } + }, + "79": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38 + } + }, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 57, + "start_line": 34 + } + }, + "81": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 24, + "start_line": 35 + }, + "While expanding the reference 'elements' in:" + ], + "start_col": 66, + "start_line": 28 + } + }, + "82": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 28, + "start_line": 36 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 25, + "start_line": 28 + } + }, + "83": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [ + { + "location": { + "end_col": 59, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 39 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 59, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 39 + } + }, + "85": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 39 + } + }, + "87": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 39 + } + }, + "89": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 41 + } + }, + "90": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 41 + } + }, + "91": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 42, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 40 + } + }, + "92": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 41 + } + }, + "93": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 41 + } + }, + "94": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 42, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 40 + } + }, + "95": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 42, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 40 + } + }, + "96": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 47 + } + }, + "97": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 47 + } + }, + "98": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 47 + } + }, + "99": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 13 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 46 + } + }, + "100": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 13 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 47 + } + }, + "101": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 14 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 47 + } + }, + "102": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 15 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 47 + } + }, + "103": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 16 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 46 + } + }, + "104": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 16 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 70, + "start_line": 47 + } + }, + "105": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 17 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 46 + } + }, + "106": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 17 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 53 + } + }, + "107": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 18 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 53 + } + }, + "108": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 19 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 53 + } + }, + "109": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 20 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 52 + } + }, + "110": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 20 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 53 + } + }, + "111": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 21 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 53 + } + }, + "112": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 22 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 53 + } + }, + "113": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 23 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 52 + } + }, + "114": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 23 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 70, + "start_line": 53 + } + }, + "115": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 24 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 52 + } + }, + "116": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 24 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 59 + } + }, + "117": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 25 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 59 + } + }, + "118": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 26 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 59 + } + }, + "119": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 27 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 60, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 58 + } + }, + "120": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 27 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 59 + } + }, + "121": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 59 + } + }, + "122": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 59 + } + }, + "123": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 30 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 60, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 58 + } + }, + "124": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 30 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 70, + "start_line": 59 + } + }, + "125": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 31 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 60, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 58 + } + }, + "126": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 31 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 65 + } + }, + "127": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 32 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 65 + } + }, + "128": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 33 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 65 + } + }, + "129": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 34 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 64 + } + }, + "130": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 34 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 65 + } + }, + "131": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 35 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 65 + } + }, + "132": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 36 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 65 + } + }, + "133": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 37 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 64 + } + }, + "134": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 37 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 70, + "start_line": 65 + } + }, + "135": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 38 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 64 + } + }, + "136": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 38 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 84 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 70 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "137": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 39 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 84 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 70 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "138": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 40 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 84 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 70 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "139": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 41 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 86 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 29, + "start_line": 71 + } + }, + "141": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 42 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 87, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 86 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 68, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 32, + "start_line": 72 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 28, + "start_line": 68 + } + }, + "143": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 43 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 87, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 88, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 86 + } + }, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 73, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 73 + } + }, + "145": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [ + { + "location": { + "end_col": 58, + "end_line": 76, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 76 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 58, + "end_line": 76, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 76 + } + }, + "147": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 76, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 76 + } + }, + "149": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 76, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 76 + } + }, + "151": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 78, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 27, + "start_line": 78 + } + }, + "152": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 78, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 16, + "start_line": 78 + } + }, + "153": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 77 + } + }, + "154": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 78, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 54, + "start_line": 78 + } + }, + "155": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 78, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 43, + "start_line": 78 + } + }, + "156": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 77 + } + }, + "157": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 77 + } + }, + "158": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 94 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 80, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 83, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 83 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 80 + } + }, + "159": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 94 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 80, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 83, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 83 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 80 + } + }, + "160": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 13 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 94 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 80, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 83, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 25, + "start_line": 83 + }, + "While expanding the reference 'state' in:" + ], + "start_col": 21, + "start_line": 80 + } + }, + "161": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 14 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 96 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 84, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 29, + "start_line": 84 + } + }, + "163": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 15 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 97, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 96 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 81, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 85, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 32, + "start_line": 85 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 28, + "start_line": 81 + } + }, + "165": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 16 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 97, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 98, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 96 + } + }, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 86, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 86 + } + }, + "167": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 89, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 17, + "start_line": 89 + }, + "While expanding the reference 'elements_end' in:" + ], + "start_col": 25, + "start_line": 29 + } + }, + "168": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 89, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 17, + "start_line": 89 + } + }, + "169": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 91, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 91 + } + }, + "171": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 93, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 61, + "start_line": 93 + } + }, + "173": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 101, + "end_line": 93, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 93 + } + }, + "174": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 101, + "end_line": 93, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 93 + } + }, + "175": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 101, + "end_line": 93, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 93 + } + }, + "176": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 106, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 105, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 95, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 96, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 96 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 25, + "start_line": 28 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 28, + "start_line": 95 + } + }, + "178": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 106, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 105, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 94, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 96, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 21, + "start_line": 96 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 19, + "start_line": 94 + } + }, + "179": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 106, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 105, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 96, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 9, + "start_line": 96 + } + }, + "180": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 99, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 99 + } + }, + "182": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 23, + "start_line": 102 + } + }, + "183": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 12, + "start_line": 102 + } + }, + "184": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 103, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 101 + } + }, + "185": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 39, + "start_line": 102 + } + }, + "187": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 103, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 101 + } + }, + "188": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 103, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 101 + } + }, + "189": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 12 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 111, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 110, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 105, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 106 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 25, + "start_line": 28 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 24, + "start_line": 105 + } + }, + "191": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 13 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 111, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 110, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 104, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 17, + "start_line": 106 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 15, + "start_line": 104 + } + }, + "192": { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 14 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 111, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 110, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "start_col": 5, + "start_line": 106 + } + }, + "193": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 15, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 27, + "start_line": 15 + } + }, + "194": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 + } + }, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 28, + "start_line": 16 + } + }, + "195": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 8, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 41, + "start_line": 19 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 17, + "start_line": 8 + } + }, + "196": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 + } + }, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 60, + "start_line": 19 + } + }, + "197": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116 + } + }, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 24, + "start_line": 26 + } + }, + "198": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 30, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 5, + "start_line": 30 + } + }, + "199": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 5, + "start_line": 31 + } + }, + "200": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 18, + "start_line": 35 + } + }, + "202": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 18, + "start_line": 36 + } + }, + "204": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 18, + "start_line": 37 + } + }, + "205": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119, + "starkware.cairo.common.hash_chain.hash_chain.next_frame": 121 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 5, + "start_line": 41 + } + }, + "206": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119, + "starkware.cairo.common.hash_chain.hash_chain.next_frame": 121 + } + }, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 42, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 5, + "start_line": 42 + } + }, + "208": { + "accessible_scopes": [ + "starkware.cairo.common.hash_chain", + "starkware.cairo.common.hash_chain.hash_chain" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, + "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 122, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, + "starkware.cairo.common.hash_chain.hash_chain.new_data": 119, + "starkware.cairo.common.hash_chain.hash_chain.next_frame": 121 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 46, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" + }, + "start_col": 5, + "start_line": 46 + } + }, + "209": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 48 + } + }, + "211": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 48 + } + }, + "213": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 49, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 54, + "start_line": 49 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 55, + "start_line": 45 + } + }, + "214": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 50, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 15, + "start_line": 50 + } + }, + "215": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 50, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 46, + "start_line": 50 + } + }, + "217": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 51, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 49 + } + }, + "219": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 14, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 52, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 52 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 27, + "start_line": 45 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 27, + "start_line": 45 + } + }, + "220": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 14, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 49, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 52, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 52 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 55, + "start_line": 45 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 54, + "start_line": 49 + } + }, + "221": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 14, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 49, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 52, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 52 + }, + "While expanding the reference 'hash' in:" + ], + "start_col": 14, + "start_line": 49 + } + }, + "222": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 14, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 52, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 52 + } + }, + "223": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 42, + "start_line": 54 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 27, + "start_line": 45 + } + }, + "224": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 46, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 65, + "start_line": 54 + }, + "While expanding the reference 'program_data_ptr' in:" + ], + "start_col": 5, + "start_line": 46 + } + }, + "225": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 54 + } + }, + "227": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 15, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 55 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 27, + "start_line": 45 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 54 + } + }, + "228": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 15, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 55 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 55, + "start_line": 45 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 55, + "start_line": 45 + } + }, + "229": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 15, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 55 + }, + "While expanding the reference 'hash' in:" + ], + "start_col": 14, + "start_line": 54 + } + }, + "230": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 15, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 9, + "start_line": 55 + } + }, + "231": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 69, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "233": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 26 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 29, + "start_line": 72 + } + }, + "235": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 137, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 10, + "start_line": 72 + } + }, + "236": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 68, + "end_line": 76, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 76 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 50, + "end_line": 80, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 80 + } + }, + "237": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 91, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 83 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 66, + "end_line": 94, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 48, + "start_line": 94 + } + }, + "239": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 94, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 94 + } + }, + "240": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 97, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 100 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 27, + "start_line": 45 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 24, + "start_line": 97 + } + }, + "241": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 30 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 98, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 45, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 100 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 55, + "start_line": 45 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 24, + "start_line": 98 + } + }, + "242": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 31 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 75, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 101, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 30, + "start_line": 101 + }, + "While expanding the reference 'program_data_ptr' in:" + ], + "start_col": 11, + "start_line": 75 + } + }, + "243": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 32 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 94, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 101, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 61, + "start_line": 101 + }, + "While expanding the reference 'use_poseidon' in:" + ], + "start_col": 76, + "start_line": 66 + } + }, + "244": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 33 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 22, + "start_line": 100 + } + }, + "246": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 106 + } + }, + "247": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 114, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 107 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 62, + "end_line": 117, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 117 + } + }, + "249": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 118, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 118 + } + }, + "250": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 119, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 31, + "start_line": 119 + } + }, + "251": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 123, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 120 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 55, + "end_line": 124, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 28, + "start_line": 124 + } + }, + "252": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 126, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 126 + } + }, + "253": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "255": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "256": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "257": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "258": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "259": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "260": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "261": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "262": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "263": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 144, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 23, + "start_line": 144 + }, + "While expanding the reference 'builtin_encodings' in:" + ], + "start_col": 5, + "start_line": 66 + } + }, + "264": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 130, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 145, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 19, + "start_line": 145 + }, + "While expanding the reference 'pre_execution_builtin_ptrs' in:" + ], + "start_col": 11, + "start_line": 130 + } + }, + "266": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 146, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 24, + "start_line": 146 + } + }, + "268": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 117, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 147, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 28, + "start_line": 147 + }, + "While expanding the reference 'builtin_list' in:" + ], + "start_col": 11, + "start_line": 117 + } + }, + "269": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 118, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 29, + "start_line": 148 + }, + "While expanding the reference 'n_builtins' in:" + ], + "start_col": 11, + "start_line": 118 + } + }, + "270": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 149, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 143 + } + }, + "272": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 18, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 185, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 152 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 33, + "end_line": 188, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 188 + } + }, + "273": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 194, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 191 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 28, + "end_line": 198, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 20, + "start_line": 198 + } + }, + "275": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + }, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 199, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 199 + } + }, + "276": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 217, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 206 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 36, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 23, + "start_line": 219 + }, + "While expanding the reference 'builtin_encodings' in:" + ], + "start_col": 5, + "start_line": 66 + } + }, + "277": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 205, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 220, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 19, + "start_line": 220 + }, + "While expanding the reference 'return_builtin_ptrs' in:" + ], + "start_col": 11, + "start_line": 205 + } + }, + "279": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 117, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 221, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 28, + "start_line": 221 + }, + "While expanding the reference 'builtin_list' in:" + ], + "start_col": 11, + "start_line": 117 + } + }, + "280": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 29, + "end_line": 199, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 222, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 23, + "start_line": 222 + }, + "While expanding the reference 'used_builtins_addr' in:" + ], + "start_col": 11, + "start_line": 199 + } + }, + "281": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 223, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 20, + "start_line": 223 + } + }, + "283": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 224, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 31, + "start_line": 218 + } + }, + "285": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [ + { + "location": { + "end_col": 26, + "end_line": 225, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 225 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 83, + "end_line": 229, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 229 + } + }, + "286": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 232, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 39, + "start_line": 232 + }, + "While expanding the reference 'self_range_check_ptr' in:" + ], + "start_col": 47, + "start_line": 65 + } + }, + "287": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 130, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 233, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 28, + "start_line": 233 + }, + "While expanding the reference 'pre_execution_builtin_ptrs' in:" + ], + "start_col": 11, + "start_line": 130 + } + }, + "289": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 205, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 234, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 27, + "start_line": 234 + }, + "While expanding the reference 'return_builtin_ptrs' in:" + ], + "start_col": 11, + "start_line": 205 + } + }, + "291": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 235, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 32, + "start_line": 235 + }, + "While expanding the reference 'builtin_instance_sizes' in:" + ], + "start_col": 38, + "start_line": 66 + } + }, + "292": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 236, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 20, + "start_line": 236 + } + }, + "294": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 237, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 232 + } + }, + "296": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 241, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 241 + } + }, + "297": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 242, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 242 + } + }, + "298": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 161, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 256, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 244 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 30, + "end_line": 205, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 258, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 259, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 259 + }, + "While trying to retrieve the implicit argument 'builtin_ptrs' in:" + ], + "start_col": 19, + "start_line": 65 + }, + "While expanding the reference 'builtin_ptrs' in:" + ], + "start_col": 25, + "start_line": 258 + }, + "While expanding the reference 'return_builtin_ptrs' in:" + ], + "start_col": 11, + "start_line": 205 + } + }, + "300": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 161, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 232, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 67, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 259, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 259 + }, + "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" + ], + "start_col": 47, + "start_line": 65 + }, + "While expanding the reference 'self_range_check_ptr' in:" + ], + "start_col": 39, + "start_line": 232 + } + }, + "301": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 161, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 259, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "start_col": 5, + "start_line": 259 + } + }, + "302": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 162, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 24, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 24 + } + }, + "304": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 38, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 27 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "306": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "307": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "308": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "309": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "310": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "311": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "312": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "313": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + } + }, + "314": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "316": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "318": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "320": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "322": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "324": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "326": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "328": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "330": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 57 + } + }, + "332": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "334": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "336": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "338": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "340": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "342": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "344": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "346": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "348": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 79, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "350": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 82, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 23, + "start_line": 82 + } + }, + "352": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 31 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [ + { + "location": { + "end_col": 48, + "end_line": 84, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 84 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 30, + "end_line": 44, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 85, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 88 + }, + "While trying to retrieve the implicit argument 'builtin_ptrs' in:" + ], + "start_col": 20, + "start_line": 153 + }, + "While expanding the reference 'builtin_ptrs' in:" + ], + "start_col": 25, + "start_line": 85 + }, + "While expanding the reference 'builtin_ptrs_before' in:" + ], + "start_col": 11, + "start_line": 44 + } + }, + "354": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 32 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 86, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 88 + }, + "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" + ], + "start_col": 48, + "start_line": 153 + }, + "While expanding the reference 'self_range_check_ptr' in:" + ], + "start_col": 32, + "start_line": 86 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 16 + } + }, + "355": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 33 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 57, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 89, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 32, + "start_line": 89 + }, + "While expanding the reference 'builtin_encodings' in:" + ], + "start_col": 11, + "start_line": 57 + } + }, + "357": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 34 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 69, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 90, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 37, + "start_line": 90 + }, + "While expanding the reference 'builtin_instance_sizes' in:" + ], + "start_col": 11, + "start_line": 69 + } + }, + "359": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 35 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 40, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 91, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 21, + "start_line": 91 + }, + "While expanding the reference 'n_tasks' in:" + ], + "start_col": 19, + "start_line": 40 + } + }, + "360": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 36 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 88 + } + }, + "362": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 180, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 96, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 96 + } + }, + "363": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 180, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 99, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 99 + } + }, + "364": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 119, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 120, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 29, + "start_line": 120 + }, + "While expanding the reference 'additional_range_checks' in:" + ], + "start_col": 35, + "start_line": 119 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 27, + "start_line": 102 + } + }, + "365": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 119, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 120, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 29, + "start_line": 120 + }, + "While expanding the reference 'additional_range_checks' in:" + ], + "start_col": 35, + "start_line": 119 + } + }, + "366": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 120, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 61, + "start_line": 120 + } + }, + "368": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 120, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 120 + } + }, + "370": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 100, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 14, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 14 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 100 + } + }, + "371": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 101, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 15, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 15 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 24, + "start_line": 101 + } + }, + "372": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 16 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 27, + "start_line": 102 + } + }, + "373": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 103, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'ecdsa_ptr' in:" + ], + "start_col": 5, + "start_line": 17 + }, + "While expanding the reference 'ecdsa_ptr' in:" + ], + "start_col": 21, + "start_line": 103 + } + }, + "374": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 104, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'bitwise_ptr' in:" + ], + "start_col": 5, + "start_line": 18 + }, + "While expanding the reference 'bitwise_ptr' in:" + ], + "start_col": 23, + "start_line": 104 + } + }, + "375": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 105, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'ec_op_ptr' in:" + ], + "start_col": 5, + "start_line": 19 + }, + "While expanding the reference 'ec_op_ptr' in:" + ], + "start_col": 21, + "start_line": 105 + } + }, + "376": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 20, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'keccak_ptr' in:" + ], + "start_col": 5, + "start_line": 20 + }, + "While expanding the reference 'keccak_ptr' in:" + ], + "start_col": 22, + "start_line": 106 + } + }, + "377": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 107, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 21 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 24, + "start_line": 107 + } + }, + "378": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 108, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 22, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + }, + "While trying to retrieve the implicit argument 'range_check96_ptr' in:" + ], + "start_col": 5, + "start_line": 22 + }, + "While expanding the reference 'range_check96_ptr' in:" + ], + "start_col": 29, + "start_line": 108 + } + }, + "379": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 24, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 122, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 122 + } + }, + "380": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 128, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 128 + } + }, + "382": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 129, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 129 + } + }, + "384": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 130, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 130 + } + }, + "385": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 + } + }, + "hints": [ + { + "location": { + "end_col": 50, + "end_line": 133, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 133 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 50, + "end_line": 133, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 133 + } + }, + "387": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 134, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 26, + "start_line": 134 + } + }, + "388": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 134, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 19, + "start_line": 134 + } + }, + "389": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 136, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 136 + } + }, + "390": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 133, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 36, + "start_line": 137 + }, + "While expanding the reference 'num_div2' in:" + ], + "start_col": 13, + "start_line": 133 + } + }, + "391": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 53, + "start_line": 137 + } + }, + "393": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 12, + "start_line": 137 + } + }, + "395": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 26, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 137 + } + }, + "396": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 156, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 156 + } + }, + "398": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 157, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 157 + }, + "While trying to retrieve the implicit argument 'builtin_ptrs' in:" + ], + "start_col": 20, + "start_line": 153 + }, + "While expanding the reference 'builtin_ptrs' in:" + ], + "start_col": 20, + "start_line": 153 + } + }, + "399": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + }, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 157, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 157 + }, + "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" + ], + "start_col": 48, + "start_line": 153 + }, + "While expanding the reference 'self_range_check_ptr' in:" + ], + "start_col": 48, + "start_line": 153 + } + }, + "400": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 157, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 9, + "start_line": 157 + } + }, + "401": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 166, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 160 + }, + "n_prefix_newlines": 1 + }, + { + "location": { + "end_col": 71, + "end_line": 167, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 167 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 71, + "end_line": 167, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 167 + } + }, + "403": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 169 + }, + "While trying to retrieve the implicit argument 'builtin_ptrs' in:" + ], + "start_col": 19, + "start_line": 65 + }, + "While expanding the reference 'builtin_ptrs' in:" + ], + "start_col": 20, + "start_line": 153 + } + }, + "404": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 153, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 67, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 169 + }, + "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" + ], + "start_col": 47, + "start_line": 65 + }, + "While expanding the reference 'self_range_check_ptr' in:" + ], + "start_col": 48, + "start_line": 153 + } + }, + "405": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 154, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 27, + "start_line": 170 + }, + "While expanding the reference 'builtin_encodings' in:" + ], + "start_col": 5, + "start_line": 154 + } + }, + "406": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 154, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 32, + "start_line": 171 + }, + "While expanding the reference 'builtin_instance_sizes' in:" + ], + "start_col": 38, + "start_line": 154 + } + }, + "407": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 167, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 22, + "start_line": 172 + }, + "While expanding the reference 'use_poseidon' in:" + ], + "start_col": 13, + "start_line": 167 + } + }, + "408": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 169 + } + }, + "410": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 28, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 154, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 176, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 27, + "start_line": 176 + }, + "While expanding the reference 'builtin_encodings' in:" + ], + "start_col": 5, + "start_line": 154 + } + }, + "411": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 28, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 154, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 32, + "start_line": 177 + }, + "While expanding the reference 'builtin_instance_sizes' in:" + ], + "start_col": 38, + "start_line": 154 + } + }, + "412": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 28, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 178, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 17, + "start_line": 178 + } + }, + "414": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 28, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 179, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 12, + "start_line": 175 + } + }, + "416": { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 29, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 207, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 208, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 179, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "start_col": 5, + "start_line": 175 + } + }, + "417": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 30, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn.a": 209, + "starkware.cairo.common.math.assert_nn.range_check_ptr": 210 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 46, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 42 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 26, + "end_line": 47, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 47 + } + }, + "418": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 30, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn.a": 209, + "starkware.cairo.common.math.assert_nn.range_check_ptr": 211 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 48, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 49, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 49 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 41 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 27, + "start_line": 48 + } + }, + "420": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 30, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn.a": 209, + "starkware.cairo.common.math.assert_nn.range_check_ptr": 211 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 49, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 49 + } + }, + "421": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 31, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_le.a": 212, + "starkware.cairo.common.math.assert_le.b": 213, + "starkware.cairo.common.math.assert_le.range_check_ptr": 214 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 53, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 54 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 41 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 53 + } + }, + "422": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 31, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_le.a": 212, + "starkware.cairo.common.math.assert_le.b": 213, + "starkware.cairo.common.math.assert_le.range_check_ptr": 214 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 15, + "start_line": 54 + } + }, + "423": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 31, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_le.a": 212, + "starkware.cairo.common.math.assert_le.b": 213, + "starkware.cairo.common.math.assert_le.range_check_ptr": 214 + } + }, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 54 + } + }, + "425": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 31, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_le.a": 212, + "starkware.cairo.common.math.assert_le.b": 213, + "starkware.cairo.common.math.assert_le.range_check_ptr": 215 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 55, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 55 + } + }, + "426": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 218 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 71 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 41 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 70 + } + }, + "427": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 218 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 15, + "start_line": 71 + }, + "While expanding the reference 'a' in:" + ], + "start_col": 36, + "start_line": 70 + } + }, + "428": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 218 + } + }, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 71 + } + }, + "430": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 219 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 15, + "start_line": 72 + }, + "While expanding the reference 'a' in:" + ], + "start_col": 36, + "start_line": 70 + } + }, + "431": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 219 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 18, + "start_line": 72 + }, + "While expanding the reference 'b' in:" + ], + "start_col": 39, + "start_line": 70 + } + }, + "432": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 219 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 72 + } + }, + "434": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn_le" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 32, + "offset": 14 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn_le.a": 216, + "starkware.cairo.common.math.assert_nn_le.b": 217, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 220 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 73, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 73 + } + }, + "435": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 27, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 27 + } + }, + "437": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 59, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 29 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 34, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 61 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 70 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 26 + } + }, + "438": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + }, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 20, + "start_line": 61 + }, + "While expanding the reference 'index' in:" + ], + "start_col": 11, + "start_line": 28 + } + }, + "439": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 29, + "start_line": 61 + } + }, + "441": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 61 + } + }, + "443": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 20 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 35, + "start_line": 62 + } + }, + "444": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 21 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.__temp49": 228, + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 23, + "start_line": 62 + } + }, + "445": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 22 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.__temp49": 228, + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_ptr": 229, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 63, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 63 + } + }, + "446": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 22 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.__temp49": 228, + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_ptr": 229, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 64, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 64 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 26 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 61 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 70 + } + }, + "447": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 23 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.__temp49": 228, + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_ptr": 229, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 64, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 21, + "start_line": 64 + }, + "While expanding the reference 'elm_ptr' in:" + ], + "start_col": 13, + "start_line": 62 + } + }, + "448": { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 24 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.__temp49": 228, + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_ptr": 229, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 + } + }, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 64, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "start_col": 5, + "start_line": 64 + } + }, + "449": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 34, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash.hash2.hash_ptr": 232, + "starkware.cairo.common.hash.hash2.x": 230, + "starkware.cairo.common.hash.hash2.y": 231 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 14, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 14 + } + }, + "450": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 34, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash.hash2.hash_ptr": 232, + "starkware.cairo.common.hash.hash2.x": 230, + "starkware.cairo.common.hash.hash2.y": 231 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 15, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 15 + } + }, + "451": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 34, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash.hash2.hash_ptr": 234, + "starkware.cairo.common.hash.hash2.result": 233, + "starkware.cairo.common.hash.hash2.x": 230, + "starkware.cairo.common.hash.hash2.y": 231 + } + }, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 18 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 12, + "start_line": 13 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 20, + "start_line": 17 + } + }, + "453": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 34, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.hash.hash2.hash_ptr": 234, + "starkware.cairo.common.hash.hash2.result": 233, + "starkware.cairo.common.hash.hash2.x": 230, + "starkware.cairo.common.hash.hash2.y": 231 + } + }, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "start_col": 20, + "start_line": 18 + }, + "While expanding the reference 'result' in:" + ], + "start_col": 18, + "start_line": 16 + } + }, + "454": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 34, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash.hash2.hash_ptr": 234, + "starkware.cairo.common.hash.hash2.result": 233, + "starkware.cairo.common.hash.hash2.x": 230, + "starkware.cairo.common.hash.hash2.y": 231 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 18 + } + }, + "455": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 0 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 18 + } + }, + "457": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 2 + }, + "reference_ids": {} + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 23, + "start_line": 19 + } + }, + "459": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_init.__fp__": 235, + "starkware.cairo.common.hash_state.hash_init.hash_state": 236 + } + }, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 21 + } + }, + "461": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_init.__fp__": 235, + "starkware.cairo.common.hash_state.hash_init.hash_state": 236 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 22, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 22 + } + }, + "463": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_init.__fp__": 235, + "starkware.cairo.common.hash_state.hash_init.hash_state": 236 + } + }, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 20, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 23, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 29, + "start_line": 23 + }, + "While expanding the reference 'hash_state' in:" + ], + "start_col": 11, + "start_line": 20 + }, + "While expanding the reference '__fp__' in:" + ], + "start_col": 10, + "start_line": 19 + } + }, + "464": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 35, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_init.__fp__": 235, + "starkware.cairo.common.hash_state.hash_init.hash_state": 236 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 23, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 23 + } + }, + "465": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 32 + } + }, + "467": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 82, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 33 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 28, + "start_line": 82 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 29 + } + }, + "468": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 30, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 34 + }, + "While expanding the reference 'data_ptr' in:" + ], + "start_col": 33, + "start_line": 30 + } + }, + "469": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 30, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 40, + "start_line": 34 + }, + "While expanding the reference 'data_length' in:" + ], + "start_col": 50, + "start_line": 30 + } + }, + "470": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 93, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 66, + "start_line": 34 + } + }, + "471": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 36, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 33 + } + }, + "473": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 23, + "start_line": 36 + } + }, + "475": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 38, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 38 + } + }, + "476": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 37, + "start_line": 39 + } + }, + "477": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.__temp50": 245, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 39 + } + }, + "478": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.__temp50": 245, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 82, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 40, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 40 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 29 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 33 + }, + "While trying to update the implicit return value 'hash_ptr' in:" + ], + "start_col": 28, + "start_line": 82 + } + }, + "479": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.__temp50": 245, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 40, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 33, + "start_line": 40 + }, + "While expanding the reference 'new_hash_state' in:" + ], + "start_col": 11, + "start_line": 37 + }, + "While expanding the reference '__fp__' in:" + ], + "start_col": 10, + "start_line": 36 + } + }, + "480": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 37, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_update.__fp__": 243, + "starkware.cairo.common.hash_state.hash_update.__temp50": 245, + "starkware.cairo.common.hash_state.hash_update.data_length": 239, + "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, + "starkware.cairo.common.hash_state.hash_update.hash": 242, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 + } + }, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 40, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 40 + } + }, + "481": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 38, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 + } + }, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 71 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 12, + "start_line": 13 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 20, + "start_line": 70 + } + }, + "482": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 38, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 + } + }, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 26, + "start_line": 71 + } + }, + "483": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 38, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 + } + }, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 57, + "start_line": 71 + } + }, + "484": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 38, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 + } + }, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 71, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 71 + } + }, + "486": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 38, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_finalize.hash": 249, + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 248, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 72, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 72 + } + }, + "487": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 85, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 85 + } + }, + "489": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 82, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 82, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 86, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 9, + "start_line": 86 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 28, + "start_line": 82 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 28, + "start_line": 82 + } + }, + "490": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 83, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 86, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 22, + "start_line": 86 + }, + "While expanding the reference 'initial_hash' in:" + ], + "start_col": 41, + "start_line": 83 + } + }, + "491": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 86, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 9, + "start_line": 86 + } + }, + "492": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 90, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 90 + } + }, + "494": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 91, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 34, + "start_line": 91 + } + }, + "496": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 91, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 91 + } + }, + "497": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 100, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 100 + } + }, + "498": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 101, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 101 + } + }, + "499": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 + } + }, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 102 + } + }, + "500": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 107, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 36, + "start_line": 107 + } + }, + "501": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 110, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 110 + } + }, + "502": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 37, + "start_line": 111 + } + }, + "503": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 111 + } + }, + "504": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 115, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 115 + } + }, + "506": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 116, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 116 + } + }, + "508": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 117, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 117 + } + }, + "509": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 120, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 120 + } + }, + "511": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts_no_padding" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, + "starkware.cairo.common.hash_state.hash_felts_no_padding.final_locals": 261, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 262, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 125, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 125 + } + }, + "512": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 40, + "start_line": 137 + } + }, + "514": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 7 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 136, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 28, + "start_line": 138 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 29 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 17, + "start_line": 136 + } + }, + "515": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 8 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 137, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 139, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 24, + "start_line": 139 + }, + "While expanding the reference 'hash_state_ptr' in:" + ], + "start_col": 10, + "start_line": 137 + } + }, + "516": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 52, + "end_line": 136, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 139, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 49, + "start_line": 139 + }, + "While expanding the reference 'data' in:" + ], + "start_col": 41, + "start_line": 136 + } + }, + "517": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 10 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 136, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 139, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 67, + "start_line": 139 + }, + "While expanding the reference 'length' in:" + ], + "start_col": 54, + "start_line": 136 + } + }, + "518": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 40, + "offset": 11 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 140, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 28, + "start_line": 138 + } + }, + "520": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 41, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 267, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 268, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 141, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 12, + "start_line": 141 + } + }, + "522": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_felts" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 41, + "offset": 9 + }, + "reference_ids": { + "starkware.cairo.common.hash_state.hash_felts.data": 263, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 269, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 268, + "starkware.cairo.common.hash_state.hash_felts.length": 264 + } + }, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 141, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 141 + } + }, + "523": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 8, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 8 + } + }, + "525": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 9, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 9, + "start_line": 9 + } + }, + "526": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [ + { + "location": { + "end_col": 41, + "end_line": 12, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 12 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 23, + "end_line": 2, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 13, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 35, + "start_line": 13 + }, + "While expanding the reference 'dst' in:" + ], + "start_col": 13, + "start_line": 2 + } + }, + "527": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 2, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 13, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 44, + "start_line": 13 + }, + "While expanding the reference 'src' in:" + ], + "start_col": 25, + "start_line": 2 + } + }, + "528": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 26, + "start_line": 17 + } + }, + "529": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 17 + } + }, + "530": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 22, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 22 + } + }, + "532": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 4 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 23, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 23 + } + }, + "534": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 27, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 24 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 44, + "end_line": 29, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 29 + } + }, + "536": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 31 + } + }, + "537": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + }, + "hints": [ + { + "location": { + "end_col": 26, + "end_line": 33, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 33 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 15, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 34 + } + }, + "538": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 41, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 41 + } + }, + "540": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 11 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 54, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 44 + }, + "n_prefix_newlines": 1 + }, + { + "location": { + "end_col": 53, + "end_line": 61, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 61 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 41, + "end_line": 43, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 77, + "end_line": 57, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 38, + "start_line": 62 + }, + "While expanding the reference 'simple_bootloader_output_ptr' in:" + ], + "start_col": 47, + "start_line": 57 + }, + "While expanding the reference 'simple_bootloader_output_start' in:" + ], + "start_col": 11, + "start_line": 43 + } + }, + "541": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 12 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 15, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 15 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 32 + } + }, + "542": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 13 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 33, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 16, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 16 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 33 + } + }, + "543": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 14 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 17, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'ecdsa_ptr' in:" + ], + "start_col": 5, + "start_line": 17 + }, + "While expanding the reference 'ecdsa_ptr' in:" + ], + "start_col": 5, + "start_line": 34 + } + }, + "544": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 15 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 18, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'bitwise_ptr' in:" + ], + "start_col": 5, + "start_line": 18 + }, + "While expanding the reference 'bitwise_ptr' in:" + ], + "start_col": 5, + "start_line": 35 + } + }, + "545": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 16 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 19, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'ec_op_ptr' in:" + ], + "start_col": 5, + "start_line": 19 + }, + "While expanding the reference 'ec_op_ptr' in:" + ], + "start_col": 5, + "start_line": 36 + } + }, + "546": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 17 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 20, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'keccak_ptr' in:" + ], + "start_col": 5, + "start_line": 20 + }, + "While expanding the reference 'keccak_ptr' in:" + ], + "start_col": 5, + "start_line": 37 + } + }, + "547": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 18 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 38, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 21 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 38 + } + }, + "548": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 19 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 22, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'range_check96_ptr' in:" + ], + "start_col": 5, + "start_line": 22 + }, + "While expanding the reference 'range_check96_ptr' in:" + ], + "start_col": 5, + "start_line": 39 + } + }, + "549": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 20 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 62 + } + }, + "551": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 293, + "__main__.main.ec_op_ptr": 294, + "__main__.main.ecdsa_ptr": 292, + "__main__.main.keccak_ptr": 295, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 291, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 63, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 63 + } + }, + "552": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 293, + "__main__.main.ec_op_ptr": 294, + "__main__.main.ecdsa_ptr": 292, + "__main__.main.keccak_ptr": 295, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 64, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 64 + } + }, + "553": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 293, + "__main__.main.ec_op_ptr": 294, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 295, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 65 + } + }, + "554": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 294, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 295, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 66 + } + }, + "555": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 295, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 67 + } + }, + "556": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 296, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 68, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 68 + } + }, + "557": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 297, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 69, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 69 + } + }, + "558": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 70, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 70 + } + }, + "559": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 75, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 72 + }, + "n_prefix_newlines": 1 + }, + { + "location": { + "end_col": 7, + "end_line": 89, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 78 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 22, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 92 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 34, + "start_line": 219 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 31 + } + }, + "560": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 1 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 15, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 62, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 92 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 53, + "start_line": 219 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 62 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 15 + } + }, + "561": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 2 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 77, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 51, + "start_line": 92 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 11, + "start_line": 77 + } + }, + "562": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 3 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 92 + } + }, + "564": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 307, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 95, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 95 + } + }, + "565": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [ + { + "location": { + "end_col": 40, + "end_line": 97, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 97 + }, + "n_prefix_newlines": 0 + }, + { + "location": { + "end_col": 59, + "end_line": 107, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 107 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 36, + "end_line": 96, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 96 + } + }, + "567": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 1 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 92, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 92 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 53, + "start_line": 219 + } + }, + "568": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 2 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 68, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 11, + "start_line": 68 + } + }, + "569": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 3 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 63, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 11, + "start_line": 63 + } + }, + "570": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 4 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 106, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 31, + "start_line": 106 + } + }, + "572": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 5 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 103, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 109, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 37, + "start_line": 109 + }, + "While expanding the reference 'simple_bootloader_output_ptr' in:" + ], + "start_col": 40, + "start_line": 103 + } + }, + "574": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 6 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 77, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 110, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 31, + "start_line": 110 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 11, + "start_line": 77 + } + }, + "575": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 7 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 52, + "end_line": 102, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 71, + "end_line": 110, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 61, + "start_line": 110 + }, + "While expanding the reference 'n_subtasks' in:" + ], + "start_col": 22, + "start_line": 102 + } + }, + "576": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 8 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 109 + } + }, + "578": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 116, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 116 + } + }, + "579": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 119, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 119 + } + }, + "580": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 149, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 121 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 31, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 31 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 9, + "start_line": 109 + }, + "While trying to update the implicit return value 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + } + }, + "581": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 1 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 32, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 32 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 9, + "start_line": 109 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + } + }, + "582": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 2 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 33, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 33 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 9, + "start_line": 109 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + } + }, + "583": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 3 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 64, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 34, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'ecdsa_ptr' in:" + ], + "start_col": 5, + "start_line": 34 + }, + "While expanding the reference 'ecdsa_ptr' in:" + ], + "start_col": 11, + "start_line": 64 + } + }, + "584": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 4 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 65, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 35, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'bitwise_ptr' in:" + ], + "start_col": 5, + "start_line": 35 + }, + "While expanding the reference 'bitwise_ptr' in:" + ], + "start_col": 11, + "start_line": 65 + } + }, + "585": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 5 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 66, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 36, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'ec_op_ptr' in:" + ], + "start_col": 5, + "start_line": 36 + }, + "While expanding the reference 'ec_op_ptr' in:" + ], + "start_col": 11, + "start_line": 66 + } + }, + "586": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 6 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 67, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 37, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'keccak_ptr' in:" + ], + "start_col": 5, + "start_line": 37 + }, + "While expanding the reference 'keccak_ptr' in:" + ], + "start_col": 11, + "start_line": 67 + } + }, + "587": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 7 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 111, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 38, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 38 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 9, + "start_line": 109 + }, + "While trying to update the implicit return value 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + } + }, + "588": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 8 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 69, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 39, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'range_check96_ptr' in:" + ], + "start_col": 5, + "start_line": 39 + }, + "While expanding the reference 'range_check96_ptr' in:" + ], + "start_col": 11, + "start_line": 69 + } + }, + "589": { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 9 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 150, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 150 + } + }, + "590": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 176, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 176 + } + }, + "592": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + } + }, + "593": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + } + }, + "594": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 2 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + } + }, + "595": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 3 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + } + }, + "596": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 4 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + } + }, + "597": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 5 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 174, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 174, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + }, + "While trying to retrieve the implicit argument 'subtasks_output' in:" + ], + "start_col": 5, + "start_line": 174 + }, + "While expanding the reference 'subtasks_output' in:" + ], + "start_col": 5, + "start_line": 174 + } + }, + "598": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 6 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 177, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 177 + } + }, + "599": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 180, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 180 + } + }, + "601": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 189, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 182 + }, + "n_prefix_newlines": 1 + }, + { + "location": { + "end_col": 7, + "end_line": 196, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 191 + }, + "n_prefix_newlines": 1 + }, + { + "location": { + "end_col": 66, + "end_line": 198, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 198 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 66, + "end_line": 198, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 198 + } + }, + "603": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 198, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 198 + } + }, + "605": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [ + { + "location": { + "end_col": 70, + "end_line": 203, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 203 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 260, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 260 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + } + }, + "606": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 2 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 261, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 261 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + } + }, + "607": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 3 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 262, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 262 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + } + }, + "608": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 4 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 263, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 263 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + } + }, + "609": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 5 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 264, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 264 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + } + }, + "610": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 6 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 174, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 204, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 50, + "start_line": 204 + }, + "While expanding the reference 'subtasks_output' in:" + ], + "start_col": 5, + "start_line": 174 + } + }, + "611": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 7 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 175, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 205, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 31, + "start_line": 205 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 3, + "start_line": 175 + } + }, + "612": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 8 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 206, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 204 + } + }, + "614": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 48, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 335, + "__main__.parse_tasks.output_ptr": 331, + "__main__.parse_tasks.pedersen_ptr": 332, + "__main__.parse_tasks.poseidon_ptr": 333, + "__main__.parse_tasks.range_check_ptr": 334, + "__main__.parse_tasks.subtasks_output": 336 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 198, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 198 + } + }, + "616": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 329, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 329 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + } + }, + "617": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 2 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 330, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 330 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + } + }, + "618": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 3 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 331, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 331 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + } + }, + "619": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 4 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 332, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 332 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + } + }, + "620": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 5 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 333, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 333 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + } + }, + "621": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 6 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 174, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 61, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 46, + "start_line": 200 + }, + "While expanding the reference 'subtasks_output' in:" + ], + "start_col": 5, + "start_line": 174 + } + }, + "622": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 7 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 175, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 98, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 81, + "start_line": 200 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 3, + "start_line": 175 + } + }, + "623": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 8 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + }, + "hints": [], + "inst": { + "end_col": 99, + "end_line": 200, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 200 + } + }, + "625": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 50, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 347, + "__main__.parse_tasks.output_ptr": 343, + "__main__.parse_tasks.pedersen_ptr": 344, + "__main__.parse_tasks.poseidon_ptr": 345, + "__main__.parse_tasks.range_check_ptr": 346, + "__main__.parse_tasks.subtasks_output": 348 + } + }, + "hints": [ + { + "location": { + "end_col": 26, + "end_line": 209, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 209 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 39, + "end_line": 175, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 212, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 42, + "start_line": 212 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 3, + "start_line": 175 + } + }, + "626": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 50, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 347, + "__main__.parse_tasks.output_ptr": 343, + "__main__.parse_tasks.pedersen_ptr": 344, + "__main__.parse_tasks.poseidon_ptr": 345, + "__main__.parse_tasks.range_check_ptr": 346, + "__main__.parse_tasks.subtasks_output": 348 + } + }, + "hints": [], + "inst": { + "end_col": 86, + "end_line": 212, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 72, + "start_line": 212 + } + }, + "628": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 50, + "offset": 2 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 347, + "__main__.parse_tasks.output_ptr": 343, + "__main__.parse_tasks.pedersen_ptr": 344, + "__main__.parse_tasks.poseidon_ptr": 345, + "__main__.parse_tasks.range_check_ptr": 346, + "__main__.parse_tasks.subtasks_output": 348 + } + }, + "hints": [], + "inst": { + "end_col": 87, + "end_line": 212, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 12, + "start_line": 212 + } + }, + "630": { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 51, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 353, + "__main__.parse_tasks.output_ptr": 349, + "__main__.parse_tasks.pedersen_ptr": 350, + "__main__.parse_tasks.poseidon_ptr": 351, + "__main__.parse_tasks.range_check_ptr": 352, + "__main__.parse_tasks.subtasks_output": 354 + } + }, + "hints": [], + "inst": { + "end_col": 88, + "end_line": 212, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 212 + } + }, + "631": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 0 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 222, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 27, + "start_line": 222 + } + }, + "632": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 1 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 222, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 222 + } + }, + "633": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 1 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 225, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 64, + "start_line": 225 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 53, + "start_line": 219 + } + }, + "634": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 2 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 226, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 14, + "start_line": 226 + } + }, + "635": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 3 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 227, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 16, + "start_line": 227 + } + }, + "636": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 4 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 357 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 228, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 44, + "start_line": 225 + } + }, + "638": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 53, + "offset": 0 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 356, + "__main__.serialize_bootloader_config.pedersen_ptr": 359, + "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 + } + }, + "hints": [], + "inst": { + "end_col": 62, + "end_line": 230, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 230 + } + }, + "639": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 53, + "offset": 0 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 361, + "__main__.serialize_bootloader_config.pedersen_ptr": 359, + "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 + } + }, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 231, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 232, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 232 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 34, + "start_line": 219 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 231 + } + }, + "641": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 53, + "offset": 1 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 361, + "__main__.serialize_bootloader_config.pedersen_ptr": 359, + "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 + } + }, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 225, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 219, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 232, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 232 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 53, + "start_line": 219 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 64, + "start_line": 225 + } + }, + "642": { + "accessible_scopes": [ + "__main__", + "__main__.serialize_bootloader_config" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 53, + "offset": 2 + }, + "reference_ids": { + "__main__.serialize_bootloader_config.__temp55": 358, + "__main__.serialize_bootloader_config.bootloader_config": 355, + "__main__.serialize_bootloader_config.output_ptr": 361, + "__main__.serialize_bootloader_config.pedersen_ptr": 359, + "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 232, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 232 + } + }, + "643": { + "accessible_scopes": [ + "__main__", + "__main__.parse_task_header" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 54, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_task_header.task_header": 363, + "__main__.parse_task_header.task_output": 364 + } + }, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 242, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 240, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 243, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 243 + }, + "While trying to retrieve the implicit argument 'task_output' in:" + ], + "start_col": 24, + "start_line": 240 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 23, + "start_line": 242 + } + }, + "645": { + "accessible_scopes": [ + "__main__", + "__main__.parse_task_header" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 54, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_task_header.task_header": 363, + "__main__.parse_task_header.task_output": 364 + } + }, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 241, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 243, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 25, + "start_line": 243 + }, + "While expanding the reference 'task_header' in:" + ], + "start_col": 23, + "start_line": 241 + } + }, + "646": { + "accessible_scopes": [ + "__main__", + "__main__.parse_task_header" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 54, + "offset": 2 + }, + "reference_ids": { + "__main__.parse_task_header.task_header": 363, + "__main__.parse_task_header.task_output": 364 + } + }, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 243, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 243 + } + }, + "647": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 267, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 267 + } + }, + "649": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 4 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 276, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 272 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 35, + "end_line": 262, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 281, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 40, + "start_line": 279 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 25, + "start_line": 28 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 262 + } + }, + "650": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 5 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 271, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 280, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 11, + "start_line": 280 + }, + "While expanding the reference 'nested_subtasks_output_len' in:" + ], + "start_col": 11, + "start_line": 271 + } + }, + "651": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 6 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 270, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 280, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 48, + "start_line": 280 + }, + "While expanding the reference 'nested_subtasks_output' in:" + ], + "start_col": 11, + "start_line": 270 + } + }, + "652": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 7 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 281, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 40, + "start_line": 279 + } + }, + "654": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 265, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 240, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 284, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 44, + "start_line": 284 + }, + "While trying to retrieve the implicit argument 'task_output' in:" + ], + "start_col": 24, + "start_line": 240 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 5, + "start_line": 265 + } + }, + "655": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 1 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_output": 371 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 284, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 44, + "start_line": 284 + } + }, + "657": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 5 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 285, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 31, + "start_line": 285 + } + }, + "659": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 6 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 285, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 285 + } + }, + "660": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 6 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 263, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 293, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 288 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 26 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 263 + } + }, + "661": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 7 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 289, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 19, + "start_line": 289 + } + }, + "662": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 8 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 290, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 18, + "start_line": 290 + } + }, + "664": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 9 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 291, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 16, + "start_line": 291 + } + }, + "665": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 10 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 292, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 13, + "start_line": 292 + } + }, + "666": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 11 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 293, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 288 + } + }, + "668": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 37 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 70, + "end_line": 297, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 22, + "start_line": 297 + } + }, + "669": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 299, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 296 + } + }, + "670": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 299, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 296 + } + }, + "671": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 376 + } + }, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 300, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 300 + } + }, + "673": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 303, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 303 + } + }, + "674": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [ + { + "location": { + "end_col": 50, + "end_line": 306, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 306 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 22, + "end_line": 260, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 260 + } + }, + "675": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 39 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 261, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 261 + } + }, + "676": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 40 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 28, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 281, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 40, + "start_line": 279 + }, + "While trying to update the implicit return value 'poseidon_ptr' in:" + ], + "start_col": 25, + "start_line": 28 + } + }, + "677": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 41 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 26, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 293, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 288 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 19, + "start_line": 26 + } + }, + "678": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 42 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 264, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 264 + } + }, + "679": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 43 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 305, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 308, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 37, + "start_line": 308 + }, + "While expanding the reference 'nested_subtasks_output' in:" + ], + "start_col": 34, + "start_line": 305 + } + }, + "681": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 44 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 266, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 309, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 31, + "start_line": 309 + }, + "While expanding the reference 'bootloader_config' in:" + ], + "start_col": 3, + "start_line": 266 + } + }, + "682": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 45 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 304, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 71, + "end_line": 309, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 61, + "start_line": 309 + }, + "While expanding the reference 'n_subtasks' in:" + ], + "start_col": 22, + "start_line": 304 + } + }, + "683": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 46 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 9, + "start_line": 308 + } + }, + "685": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 314, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 314 + } + }, + "686": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 169, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 260, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 260 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 9, + "start_line": 308 + }, + "While trying to update the implicit return value 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 169 + } + }, + "687": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 1 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 170, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 261, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 261 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 9, + "start_line": 308 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 170 + } + }, + "688": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 2 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 171, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 262, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 262 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 9, + "start_line": 308 + }, + "While trying to update the implicit return value 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 171 + } + }, + "689": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 3 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 172, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 263, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 263 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 9, + "start_line": 308 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 172 + } + }, + "690": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 4 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 173, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 310, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 264, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 264 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 9, + "start_line": 308 + }, + "While trying to update the implicit return value 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 173 + } + }, + "691": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 5 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 300, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 265, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + }, + "While trying to retrieve the implicit argument 'task_output' in:" + ], + "start_col": 5, + "start_line": 265 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 11, + "start_line": 300 + } + }, + "692": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 6 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 389, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 385, + "__main__.unpack_composite_packed_task.pedersen_ptr": 386, + "__main__.unpack_composite_packed_task.poseidon_ptr": 387, + "__main__.unpack_composite_packed_task.range_check_ptr": 388, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 315, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 315 + } + }, + "693": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_output": 397 + } + }, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 336, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 336 + } + }, + "695": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 2 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_output": 397 + } + }, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 334, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 240, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 339, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 44, + "start_line": 339 + }, + "While trying to retrieve the implicit argument 'task_output' in:" + ], + "start_col": 24, + "start_line": 240 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 5, + "start_line": 334 + } + }, + "696": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 3 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_output": 397 + } + }, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 339, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 44, + "start_line": 339 + } + }, + "698": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 7 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 398 + } + }, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 340, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 340 + } + }, + "699": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 7 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 343, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 52, + "start_line": 343 + } + }, + "700": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 8 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 343, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 343 + } + }, + "701": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 8 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 343, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 52, + "start_line": 343 + } + }, + "702": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 9 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 392, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 343, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 343 + } + }, + "703": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 9 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 349, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 25, + "start_line": 349 + } + }, + "704": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 10 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 349, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 349 + } + }, + "706": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 10 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 346, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 350, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 16, + "start_line": 350 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 346 + } + }, + "708": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 11 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 340, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 350, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 32, + "start_line": 350 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 11, + "start_line": 340 + } + }, + "709": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 12 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 349, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 350, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 49, + "start_line": 350 + }, + "While expanding the reference 'output_size' in:" + ], + "start_col": 11, + "start_line": 349 + } + }, + "710": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 58, + "offset": 13 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 396, + "__main__.unpack_plain_packed_task.output_ptr": 403, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 400 + } + }, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 350, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 350 + } + }, + "712": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 0 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 346, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 353, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 329, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 329 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 353 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 346 + } + }, + "714": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 1 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 353, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 329, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'output_ptr' in:" + ], + "start_col": 5, + "start_line": 329 + }, + "While expanding the reference 'output_ptr' in:" + ], + "start_col": 22, + "start_line": 353 + } + }, + "715": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 2 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 330, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 330, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 330 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 330 + } + }, + "716": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 3 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 331, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 331, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 331 + }, + "While expanding the reference 'poseidon_ptr' in:" + ], + "start_col": 5, + "start_line": 331 + } + }, + "717": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 4 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 332, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 332, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 332 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 332 + } + }, + "718": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 5 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 355, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 333, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'n_total_tasks' in:" + ], + "start_col": 5, + "start_line": 333 + }, + "While expanding the reference 'n_total_tasks' in:" + ], + "start_col": 25, + "start_line": 355 + } + }, + "720": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 6 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 354, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 334, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + }, + "While trying to retrieve the implicit argument 'task_output' in:" + ], + "start_col": 5, + "start_line": 334 + }, + "While expanding the reference 'task_output' in:" + ], + "start_col": 23, + "start_line": 354 + } + }, + "721": { + "accessible_scopes": [ + "__main__", + "__main__.unpack_plain_packed_task" + ], + "flow_tracking_data": { + "ap_tracking": { + "group": 59, + "offset": 7 + }, + "reference_ids": { + "__main__.unpack_plain_packed_task.__temp58": 401, + "__main__.unpack_plain_packed_task.__temp59": 402, + "__main__.unpack_plain_packed_task.__temp60": 404, + "__main__.unpack_plain_packed_task.__temp61": 409, + "__main__.unpack_plain_packed_task.bootloader_config": 391, + "__main__.unpack_plain_packed_task.n_total_tasks": 408, + "__main__.unpack_plain_packed_task.output_ptr": 406, + "__main__.unpack_plain_packed_task.output_size": 405, + "__main__.unpack_plain_packed_task.pedersen_ptr": 393, + "__main__.unpack_plain_packed_task.poseidon_ptr": 394, + "__main__.unpack_plain_packed_task.range_check_ptr": 395, + "__main__.unpack_plain_packed_task.task_header": 399, + "__main__.unpack_plain_packed_task.task_output": 407 + } + }, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 356, + "input_file": { + "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" + }, + "start_col": 5, + "start_line": 356 + } + } + } + }, + "hints": { + "12": [ + { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.inner_select_builtins", + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" + ], + "code": "# A builtin should be selected iff its encoding appears in the selected encodings list\n# and the list wasn't exhausted.\n# Note that testing inclusion by a single comparison is possible since the lists are sorted.\nids.select_builtin = int(\n n_selected_builtins > 0 and memory[ids.selected_encodings] == memory[ids.all_encodings])\nif ids.select_builtin:\n n_selected_builtins = n_selected_builtins - 1", + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 3 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 + } + } + } + ], + "34": [ + { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "code": "vm_enter_scope({'n_selected_builtins': ids.n_selected_builtins})", + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 2 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + } + } + ], + "45": [ + { + "accessible_scopes": [ + "starkware.cairo.builtin_selection.select_input_builtins", + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" + ], + "code": "vm_exit_scope()", + "flow_tracking_data": { + "ap_tracking": { + "group": 5, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 + } + } + } + ], + "83": [ + { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "code": "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= 10)", + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + } + } + ], + "145": [ + { + "accessible_scopes": [ + "starkware.cairo.common.builtin_poseidon.poseidon", + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" + ], + "code": "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= 2)", + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 + } + } + } + ], + "236": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "ids.program_data_ptr = program_data_base = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "237": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "from starkware.cairo.bootloaders.simple_bootloader.utils import load_program\n\n# Call load_program to load the program header and code to memory.\nprogram_address, program_data_size = load_program(\n task=task, memory=memory, program_header=ids.program_header,\n builtins_offset=ids.ProgramHeader.builtin_list)\nsegments.finalize(program_data_base.segment_index, program_data_size)", + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 28 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "247": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "# Validate hash.\nfrom starkware.cairo.bootloaders.hash_program import compute_program_hash_chain\n\nassert memory[ids.output_ptr + 1] == compute_program_hash_chain(\n program=task.get_program(),\n use_poseidon=bool(ids.use_poseidon)), 'Computed hash does not match input.'", + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "251": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "# Sanity check.\nassert ids.program_address == program_address", + "flow_tracking_data": { + "ap_tracking": { + "group": 17, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "272": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "from starkware.cairo.bootloaders.simple_bootloader.objects import (\n CairoPieTask,\n RunProgramTask,\n Task,\n)\nfrom starkware.cairo.bootloaders.simple_bootloader.utils import (\n load_cairo_pie,\n prepare_output_runner,\n)\n\nassert isinstance(task, Task)\nn_builtins = len(task.get_program().builtins)\nnew_task_locals = {}\nif isinstance(task, RunProgramTask):\n new_task_locals['program_input'] = task.program_input\n new_task_locals['WITH_BOOTLOADER'] = True\n\n vm_load_program(task.program, program_address)\nelif isinstance(task, CairoPieTask):\n ret_pc = ids.ret_pc_label.instruction_offset_ - ids.call_task.instruction_offset_ + pc\n load_cairo_pie(\n task=task.cairo_pie, memory=memory, segments=segments,\n program_address=program_address, execution_segment_address= ap - n_builtins,\n builtin_runners=builtin_runners, ret_fp=fp, ret_pc=ret_pc)\nelse:\n raise NotImplementedError(f'Unexpected task type: {type(task).__name__}.')\n\noutput_runner_data = prepare_output_runner(\n task=task,\n output_builtin=output_builtin,\n output_ptr=ids.pre_execution_builtin_ptrs.output)\nvm_enter_scope(new_task_locals)", + "flow_tracking_data": { + "ap_tracking": { + "group": 18, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "273": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "vm_exit_scope()\n# Note that bootloader_input will only be available in the next hint.", + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 + } + } + } + ], + "276": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "from starkware.cairo.bootloaders.simple_bootloader.utils import write_return_builtins\n\n# Fill the values of all builtin pointers after executing the task.\nbuiltins = task.get_program().builtins\nwrite_return_builtins(\n memory=memory, return_builtins_addr=ids.return_builtin_ptrs.address_,\n used_builtins=builtins, used_builtins_addr=ids.used_builtins_addr,\n pre_execution_builtins_addr=ids.pre_execution_builtin_ptrs.address_, task=task)\n\nvm_enter_scope({'n_selected_builtins': n_builtins})", + "flow_tracking_data": { + "ap_tracking": { + "group": 19, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + } + } + ], + "285": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "vm_exit_scope()", + "flow_tracking_data": { + "ap_tracking": { + "group": 20, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + } + } + ], + "298": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.execute_task", + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" + ], + "code": "from starkware.cairo.bootloaders.simple_bootloader.utils import get_task_fact_topology\n\n# Add the fact topology of the current task to 'fact_topologies'.\noutput_start = ids.pre_execution_builtin_ptrs.output\noutput_end = ids.return_builtin_ptrs.output\nfact_topologies.append(get_task_fact_topology(\n output_size=output_end - output_start,\n task=task,\n output_builtin=output_builtin,\n output_runner_data=output_runner_data,\n))", + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 + } + } + } + ], + "304": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "code": "n_tasks = len(simple_bootloader_input.tasks)\nmemory[ids.output_ptr] = n_tasks\n\n# Task range checks are located right after simple bootloader validation range checks, and\n# this is validated later in this function.\nids.task_range_check_ptr = ids.range_check_ptr + ids.BuiltinData.SIZE * n_tasks\n\n# A list of fact_toplogies that instruct how to generate the fact from the program output\n# for each task.\nfact_topologies = []", + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 29 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 162, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + } + } + ], + "352": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" + ], + "code": "tasks = simple_bootloader_input.tasks", + "flow_tracking_data": { + "ap_tracking": { + "group": 22, + "offset": 31 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 + } + } + } + ], + "385": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" + ], + "code": "memory[ap] = to_felt_or_relocatable(ids.num // 2)", + "flow_tracking_data": { + "ap_tracking": { + "group": 25, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 + } + } + } + ], + "401": [ + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "code": "from starkware.cairo.bootloaders.simple_bootloader.objects import Task\n\n# Pass current task to execute_task.\ntask_id = len(simple_bootloader_input.tasks) - ids.n_tasks\ntask = simple_bootloader_input.tasks[task_id].load_task()", + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + } + }, + { + "accessible_scopes": [ + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" + ], + "code": "memory[ap] = to_felt_or_relocatable(1 if task.use_poseidon else 0)", + "flow_tracking_data": { + "ap_tracking": { + "group": 27, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 + } + } + } + ], + "417": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "code": "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'", + "flow_tracking_data": { + "ap_tracking": { + "group": 30, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn.a": 209, + "starkware.cairo.common.math.assert_nn.range_check_ptr": 210 + } + } + } + ], + "437": [ + { + "accessible_scopes": [ + "starkware.cairo.common.find_element", + "starkware.cairo.common.find_element.find_element" + ], + "code": "array_ptr = ids.array_ptr\nelm_size = ids.elm_size\nassert isinstance(elm_size, int) and elm_size > 0, \\\n f'Invalid value for elm_size. Got: {elm_size}.'\nkey = ids.key\n\nif '__find_element_index' in globals():\n ids.index = __find_element_index\n found_key = memory[array_ptr + elm_size * __find_element_index]\n assert found_key == key, \\\n f'Invalid index found in __find_element_index. index: {__find_element_index}, ' \\\n f'expected key {key}, found key: {found_key}.'\n # Delete __find_element_index to make sure it's not used for the next calls.\n del __find_element_index\nelse:\n n_elms = ids.n_elms\n assert isinstance(n_elms, int) and n_elms >= 0, \\\n f'Invalid value for n_elms. Got: {n_elms}.'\n if '__find_element_max_size' in globals():\n assert n_elms <= __find_element_max_size, \\\n f'find_element() can only be used with n_elms<={__find_element_max_size}. ' \\\n f'Got: n_elms={n_elms}.'\n\n for i in range(n_elms):\n if memory[array_ptr + elm_size * i] == key:\n ids.index = i\n break\n else:\n raise ValueError(f'Key {key} was not found.')", + "flow_tracking_data": { + "ap_tracking": { + "group": 33, + "offset": 1 + }, + "reference_ids": { + "starkware.cairo.common.find_element.find_element.array_ptr": 221, + "starkware.cairo.common.find_element.find_element.elm_size": 222, + "starkware.cairo.common.find_element.find_element.index": 226, + "starkware.cairo.common.find_element.find_element.key": 224, + "starkware.cairo.common.find_element.find_element.n_elms": 223, + "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 + } + } + } + ], + "526": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "vm_enter_scope({'n': ids.len})", + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + } + } + ], + "534": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "n -= 1\nids.continue_copying = 1 if n > 0 else 0", + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + } + } + ], + "537": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "vm_exit_scope()", + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 6 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.__temp53": 275, + "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, + "starkware.cairo.common.memcpy.memcpy.dst": 270, + "starkware.cairo.common.memcpy.memcpy.frame": 274, + "starkware.cairo.common.memcpy.memcpy.len": 272, + "starkware.cairo.common.memcpy.memcpy.next_frame": 277, + "starkware.cairo.common.memcpy.memcpy.src": 271 + } + } + } + ], + "540": [ + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "from starkware.cairo.bootloaders.bootloader.objects import BootloaderInput\nbootloader_input = BootloaderInput.Schema().load(program_input)\n\nids.simple_bootloader_output_start = segments.add()\n\n# Change output builtin state to a different segment in preparation for calling the\n# simple bootloader.\noutput_builtin_state = output_builtin.get_state()\noutput_builtin.new_state(base=ids.simple_bootloader_output_start)", + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 11 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_start": 287 + } + } + }, + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "simple_bootloader_input = bootloader_input", + "flow_tracking_data": { + "ap_tracking": { + "group": 43, + "offset": 11 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 282, + "__main__.main.ec_op_ptr": 283, + "__main__.main.ecdsa_ptr": 281, + "__main__.main.keccak_ptr": 284, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 279, + "__main__.main.poseidon_ptr": 285, + "__main__.main.range_check96_ptr": 286, + "__main__.main.range_check_ptr": 280, + "__main__.main.simple_bootloader_output_ptr": 288, + "__main__.main.simple_bootloader_output_start": 287 + } + } + } + ], + "559": [ + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "# Restore the bootloader's output builtin state.\noutput_builtin.set_state(output_builtin_state)", + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + } + }, + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "from starkware.cairo.bootloaders.bootloader.objects import BootloaderConfig\nbootloader_config: BootloaderConfig = bootloader_input.bootloader_config\n\nids.bootloader_config = segments.gen_arg(\n [\n bootloader_config.simple_bootloader_program_hash,\n len(bootloader_config.supported_cairo_verifier_program_hashes),\n bootloader_config.supported_cairo_verifier_program_hashes,\n ],\n)", + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_ptr": 278, + "__main__.main.pedersen_ptr": 290, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + } + } + ], + "565": [ + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "output_start = ids.output_ptr", + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 289, + "__main__.main.simple_bootloader_output_start": 287 + } + } + }, + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "packed_outputs = bootloader_input.packed_outputs", + "flow_tracking_data": { + "ap_tracking": { + "group": 45, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 314, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 310, + "__main__.main.pedersen_ptr": 308, + "__main__.main.poseidon_ptr": 303, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 298, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 313, + "__main__.main.simple_bootloader_output_start": 287 + } + } + } + ], + "580": [ + { + "accessible_scopes": [ + "__main__", + "__main__.main" + ], + "code": "from typing import List\n\nfrom starkware.cairo.bootloaders.bootloader.utils import compute_fact_topologies\nfrom starkware.cairo.bootloaders.fact_topology import FactTopology\nfrom starkware.cairo.bootloaders.simple_bootloader.utils import (\n configure_fact_topologies,\n write_to_fact_topologies_file,\n)\n\n# Compute the fact topologies of the plain packed outputs based on packed_outputs and\n# fact_topologies of the inner tasks.\nplain_fact_topologies: List[FactTopology] = compute_fact_topologies(\n packed_outputs=packed_outputs, fact_topologies=fact_topologies,\n)\n\n# Configure the memory pages in the output builtin, based on plain_fact_topologies.\nconfigure_fact_topologies(\n fact_topologies=plain_fact_topologies, output_start=output_start,\n output_builtin=output_builtin,\n)\n\n# Dump fact topologies to a json file.\nif bootloader_input.fact_topologies_path is not None:\n write_to_fact_topologies_file(\n fact_topologies_path=bootloader_input.fact_topologies_path,\n fact_topologies=plain_fact_topologies,\n )", + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 0 + }, + "reference_ids": { + "__main__.main.bitwise_ptr": 300, + "__main__.main.bootloader_config": 306, + "__main__.main.ec_op_ptr": 301, + "__main__.main.ecdsa_ptr": 299, + "__main__.main.keccak_ptr": 302, + "__main__.main.n_subtasks": 312, + "__main__.main.n_total_tasks": 319, + "__main__.main.output_n_total_tasks_ptr": 309, + "__main__.main.output_ptr": 315, + "__main__.main.parse_tasks_end": 321, + "__main__.main.pedersen_ptr": 316, + "__main__.main.poseidon_ptr": 317, + "__main__.main.range_check96_ptr": 304, + "__main__.main.range_check_ptr": 318, + "__main__.main.simple_bootloader_output_end": 305, + "__main__.main.simple_bootloader_output_ptr": 320, + "__main__.main.simple_bootloader_output_start": 287 + } + } + } + ], + "601": [ + { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "code": "from starkware.cairo.bootloaders.bootloader.objects import PackedOutput\n\ntask_id = len(packed_outputs) - ids.n_subtasks\npacked_output: PackedOutput = packed_outputs[task_id]\n\nvm_enter_scope(new_scope_locals=dict(packed_output=packed_output))", + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + } + }, + { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "code": "from starkware.cairo.bootloaders.bootloader.objects import (\n CompositePackedOutput,\n PlainPackedOutput,\n)", + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + } + }, + { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "code": "memory[ap] = to_felt_or_relocatable(isinstance(packed_output, PlainPackedOutput))", + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + } + } + ], + "605": [ + { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "code": "assert isinstance(packed_output, CompositePackedOutput)", + "flow_tracking_data": { + "ap_tracking": { + "group": 47, + "offset": 1 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 328, + "__main__.parse_tasks.output_ptr": 324, + "__main__.parse_tasks.pedersen_ptr": 325, + "__main__.parse_tasks.poseidon_ptr": 326, + "__main__.parse_tasks.range_check_ptr": 327, + "__main__.parse_tasks.subtasks_output": 329 + } + } + } + ], + "625": [ + { + "accessible_scopes": [ + "__main__", + "__main__.parse_tasks" + ], + "code": "vm_exit_scope()", + "flow_tracking_data": { + "ap_tracking": { + "group": 50, + "offset": 0 + }, + "reference_ids": { + "__main__.parse_tasks.__temp54": 330, + "__main__.parse_tasks.bootloader_config": 322, + "__main__.parse_tasks.n_subtasks": 323, + "__main__.parse_tasks.n_total_tasks": 347, + "__main__.parse_tasks.output_ptr": 343, + "__main__.parse_tasks.pedersen_ptr": 344, + "__main__.parse_tasks.poseidon_ptr": 345, + "__main__.parse_tasks.range_check_ptr": 346, + "__main__.parse_tasks.subtasks_output": 348 + } + } + } + ], + "649": [ + { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "code": "data = packed_output.elements_for_hash()\nids.nested_subtasks_output_len = len(data)\nids.nested_subtasks_output = segments.gen_arg(data)", + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 4 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 368, + "__main__.unpack_composite_packed_task.range_check_ptr": 369, + "__main__.unpack_composite_packed_task.task_output": 371 + } + } + } + ], + "674": [ + { + "accessible_scopes": [ + "__main__", + "__main__.unpack_composite_packed_task" + ], + "code": "packed_outputs = packed_output.subtasks", + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 38 + }, + "reference_ids": { + "__main__.unpack_composite_packed_task.__temp56": 378, + "__main__.unpack_composite_packed_task.__temp57": 380, + "__main__.unpack_composite_packed_task.bootloader_config": 365, + "__main__.unpack_composite_packed_task.n_subtasks": 383, + "__main__.unpack_composite_packed_task.n_total_tasks": 370, + "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, + "__main__.unpack_composite_packed_task.output_ptr": 366, + "__main__.unpack_composite_packed_task.pedersen_ptr": 367, + "__main__.unpack_composite_packed_task.poseidon_ptr": 374, + "__main__.unpack_composite_packed_task.range_check_ptr": 379, + "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, + "__main__.unpack_composite_packed_task.task_header": 377, + "__main__.unpack_composite_packed_task.task_output": 381 + } + } + } + ] + }, + "identifiers": { + "__main__.BootloaderConfig": { + "full_name": "__main__.BootloaderConfig", + "members": { + "simple_bootloader_program_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "supported_cairo_verifier_program_hashes": { + "cairo_type": "felt*", + "offset": 2 + }, + "supported_cairo_verifier_program_hashes_len": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.CairoVerifierOutput": { + "destination": "starkware.cairo.cairo_verifier.objects.CairoVerifierOutput", + "type": "alias" + }, + "__main__.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "__main__.PoseidonBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", + "type": "alias" + }, + "__main__.TaskOutputHeader": { + "full_name": "__main__.TaskOutputHeader", + "members": { + "program_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "size": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "__main__.find_element": { + "destination": "starkware.cairo.common.find_element.find_element", + "type": "alias" + }, + "__main__.hash_felts": { + "destination": "starkware.cairo.common.hash_state.hash_felts", + "type": "alias" + }, + "__main__.main": { + "decorators": [], + "pc": 538, + "type": "function" + }, + "__main__.main.Args": { + "full_name": "__main__.main.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.main.ImplicitArgs": { + "full_name": "__main__.main.ImplicitArgs", + "members": { + "bitwise_ptr": { + "cairo_type": "felt", + "offset": 4 + }, + "ec_op_ptr": { + "cairo_type": "felt", + "offset": 5 + }, + "ecdsa_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "keccak_ptr": { + "cairo_type": "felt", + "offset": 6 + }, + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 7 + }, + "range_check96_ptr": { + "cairo_type": "felt", + "offset": 8 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 9, + "type": "struct" + }, + "__main__.main.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.main.SIZEOF_LOCALS": { + "type": "const", + "value": 11 + }, + "__main__.main.bitwise_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.bitwise_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 554, + "value": "[cast(fp + 3, felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "full_name": "__main__.main.bootloader_config", + "references": [ + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 559, + "value": "[cast(fp + 9, __main__.BootloaderConfig**)]" + } + ], + "type": "reference" + }, + "__main__.main.ec_op_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.ec_op_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 555, + "value": "[cast(fp + 4, felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.ecdsa_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.ecdsa_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-8), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 553, + "value": "[cast(fp + 2, felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.keccak_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.keccak_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 556, + "value": "[cast(fp + 5, felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.n_subtasks": { + "cairo_type": "felt", + "full_name": "__main__.main.n_subtasks", + "references": [ + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast([fp], felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.n_total_tasks": { + "cairo_type": "felt", + "full_name": "__main__.main.n_total_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast(0, felt)" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-2), felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.output_n_total_tasks_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.main.output_n_total_tasks_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast(fp + 10, felt**)]" + } + ], + "type": "reference" + }, + "__main__.main.output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.main.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-11), felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 564, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast([ap + (-2)] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-6), felt**)]" + } + ], + "type": "reference" + }, + "__main__.main.parse_tasks_end": { + "cairo_type": "felt*", + "full_name": "__main__.main.parse_tasks_end", + "references": [ + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "__main__.main.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "__main__.main.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 564, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.main.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "__main__.main.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 557, + "value": "[cast(fp + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.main.range_check96_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.range_check96_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 558, + "value": "[cast(fp + 7, felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.range_check_ptr": { + "cairo_type": "felt", + "full_name": "__main__.main.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 552, + "value": "[cast(fp + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-3), felt*)]" + } + ], + "type": "reference" + }, + "__main__.main.simple_bootloader_output_end": { + "cairo_type": "felt*", + "full_name": "__main__.main.simple_bootloader_output_end", + "references": [ + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 559, + "value": "[cast(fp + 8, felt**)]" + } + ], + "type": "reference" + }, + "__main__.main.simple_bootloader_output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.main.simple_bootloader_output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 11 + }, + "pc": 540, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast([fp] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "__main__.main.simple_bootloader_output_start": { + "cairo_type": "felt*", + "full_name": "__main__.main.simple_bootloader_output_start", + "references": [ + { + "ap_tracking_data": { + "group": 43, + "offset": 11 + }, + "pc": 540, + "value": "[cast(fp, felt**)]" + } + ], + "type": "reference" + }, + "__main__.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__main__.parse_task_header": { + "decorators": [], + "pc": 643, + "type": "function" + }, + "__main__.parse_task_header.Args": { + "full_name": "__main__.parse_task_header.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__main__.parse_task_header.ImplicitArgs": { + "full_name": "__main__.parse_task_header.ImplicitArgs", + "members": { + "task_output": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.parse_task_header.Return": { + "cairo_type": "(task_header: __main__.TaskOutputHeader*)", + "type": "type_definition" + }, + "__main__.parse_task_header.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.parse_task_header.task_header": { + "cairo_type": "__main__.TaskOutputHeader*", + "full_name": "__main__.parse_task_header.task_header", + "references": [ + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "[cast(fp + (-3), __main__.TaskOutputHeader**)]" + } + ], + "type": "reference" + }, + "__main__.parse_task_header.task_output": { + "cairo_type": "felt*", + "full_name": "__main__.parse_task_header.task_output", + "references": [ + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "cast([fp + (-3)] + 2, felt*)" + } + ], + "type": "reference" + }, + "__main__.parse_tasks": { + "decorators": [], + "pc": 590, + "type": "function" + }, + "__main__.parse_tasks.Args": { + "full_name": "__main__.parse_tasks.Args", + "members": { + "bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "offset": 0 + }, + "n_subtasks": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "__main__.parse_tasks.ImplicitArgs": { + "full_name": "__main__.parse_tasks.ImplicitArgs", + "members": { + "n_total_tasks": { + "cairo_type": "felt", + "offset": 4 + }, + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 2 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "subtasks_output": { + "cairo_type": "felt*", + "offset": 5 + } + }, + "size": 6, + "type": "struct" + }, + "__main__.parse_tasks.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.parse_tasks.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.parse_tasks.__temp54": { + "cairo_type": "felt", + "full_name": "__main__.parse_tasks.__temp54", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 1 + }, + "pc": 603, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "full_name": "__main__.parse_tasks.bootloader_config", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-4), __main__.BootloaderConfig**)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.n_subtasks": { + "cairo_type": "felt", + "full_name": "__main__.parse_tasks.n_subtasks", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.n_total_tasks": { + "cairo_type": "felt", + "full_name": "__main__.parse_tasks.n_total_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-2), felt*)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.parse_tasks.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-10), felt**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-6), felt**)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "__main__.parse_tasks.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-9), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "__main__.parse_tasks.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.range_check_ptr": { + "cairo_type": "felt", + "full_name": "__main__.parse_tasks.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-3), felt*)]" + } + ], + "type": "reference" + }, + "__main__.parse_tasks.subtasks_output": { + "cairo_type": "felt*", + "full_name": "__main__.parse_tasks.subtasks_output", + "references": [ + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "__main__.poseidon_hash_many": { + "destination": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many", + "type": "alias" + }, + "__main__.run_simple_bootloader": { + "destination": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader", + "type": "alias" + }, + "__main__.serialize_bootloader_config": { + "decorators": [], + "pc": 631, + "type": "function" + }, + "__main__.serialize_bootloader_config.Args": { + "full_name": "__main__.serialize_bootloader_config.Args", + "members": { + "bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.serialize_bootloader_config.ImplicitArgs": { + "full_name": "__main__.serialize_bootloader_config.ImplicitArgs", + "members": { + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "__main__.serialize_bootloader_config.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.serialize_bootloader_config.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.serialize_bootloader_config.__temp55": { + "cairo_type": "felt", + "full_name": "__main__.serialize_bootloader_config.__temp55", + "references": [ + { + "ap_tracking_data": { + "group": 52, + "offset": 1 + }, + "pc": 632, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.serialize_bootloader_config.bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "full_name": "__main__.serialize_bootloader_config.bootloader_config", + "references": [ + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + } + ], + "type": "reference" + }, + "__main__.serialize_bootloader_config.output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.serialize_bootloader_config.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 639, + "value": "cast([fp + (-5)] + 2, felt*)" + } + ], + "type": "reference" + }, + "__main__.serialize_bootloader_config.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "__main__.serialize_bootloader_config.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 638, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": { + "cairo_type": "felt", + "full_name": "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash", + "references": [ + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 638, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task": { + "decorators": [], + "pc": 647, + "type": "function" + }, + "__main__.unpack_composite_packed_task.Args": { + "full_name": "__main__.unpack_composite_packed_task.Args", + "members": { + "bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.unpack_composite_packed_task.ImplicitArgs": { + "full_name": "__main__.unpack_composite_packed_task.ImplicitArgs", + "members": { + "n_total_tasks": { + "cairo_type": "felt", + "offset": 4 + }, + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 2 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "task_output": { + "cairo_type": "felt*", + "offset": 5 + } + }, + "size": 6, + "type": "struct" + }, + "__main__.unpack_composite_packed_task.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.unpack_composite_packed_task.SIZEOF_LOCALS": { + "type": "const", + "value": 4 + }, + "__main__.unpack_composite_packed_task.__temp56": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.__temp56", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 6 + }, + "pc": 659, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.__temp57": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.__temp57", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 669, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "full_name": "__main__.unpack_composite_packed_task.bootloader_config", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.n_subtasks": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.n_subtasks", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "[cast([fp], felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.n_total_tasks": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.n_total_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-2), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.nested_subtasks_output": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_composite_packed_task.nested_subtasks_output", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 4 + }, + "pc": 649, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "cast([fp] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.nested_subtasks_output_len": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.nested_subtasks_output_len", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 4 + }, + "pc": 649, + "value": "[cast(fp + 1, felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.nested_subtasks_output_start": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_composite_packed_task.nested_subtasks_output_start", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "[cast(fp + 3, felt**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_composite_packed_task.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-6), felt**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "__main__.unpack_composite_packed_task.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "__main__.unpack_composite_packed_task.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 0 + }, + "pc": 654, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.range_check_ptr": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 37 + }, + "pc": 668, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-3), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.subtasks_output_hash": { + "cairo_type": "felt", + "full_name": "__main__.unpack_composite_packed_task.subtasks_output_hash", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 0 + }, + "pc": 654, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.task_header": { + "cairo_type": "__main__.TaskOutputHeader*", + "full_name": "__main__.unpack_composite_packed_task.task_header", + "references": [ + { + "ap_tracking_data": { + "group": 56, + "offset": 5 + }, + "pc": 657, + "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_composite_packed_task.task_output": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_composite_packed_task.task_output", + "references": [ + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 5 + }, + "pc": 657, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 673, + "value": "[cast(fp + 2, felt**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task": { + "decorators": [], + "pc": 693, + "type": "function" + }, + "__main__.unpack_plain_packed_task.Args": { + "full_name": "__main__.unpack_plain_packed_task.Args", + "members": { + "bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.unpack_plain_packed_task.ImplicitArgs": { + "full_name": "__main__.unpack_plain_packed_task.ImplicitArgs", + "members": { + "n_total_tasks": { + "cairo_type": "felt", + "offset": 4 + }, + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 2 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "task_output": { + "cairo_type": "felt*", + "offset": 5 + } + }, + "size": 6, + "type": "struct" + }, + "__main__.unpack_plain_packed_task.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.unpack_plain_packed_task.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "__main__.unpack_plain_packed_task.__temp58": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.__temp58", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 8 + }, + "pc": 700, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.__temp59": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.__temp59", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 9 + }, + "pc": 702, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.__temp60": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.__temp60", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 10 + }, + "pc": 704, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.__temp61": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.__temp61", + "references": [ + { + "ap_tracking_data": { + "group": 59, + "offset": 1 + }, + "pc": 714, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.bootloader_config": { + "cairo_type": "__main__.BootloaderConfig*", + "full_name": "__main__.unpack_plain_packed_task.bootloader_config", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.n_total_tasks": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.n_total_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp + (-5)] + 1, felt)" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.output_ptr": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_plain_packed_task.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 9 + }, + "pc": 703, + "value": "cast([fp + (-9)] + 2, felt*)" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp + (-9)] + 2 + [fp + 1], felt*)" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.output_size": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.output_size", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 10 + }, + "pc": 706, + "value": "[cast(fp + 1, felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "__main__.unpack_plain_packed_task.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "__main__.unpack_plain_packed_task.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.range_check_ptr": { + "cairo_type": "felt", + "full_name": "__main__.unpack_plain_packed_task.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-6), felt*)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.task_header": { + "cairo_type": "__main__.TaskOutputHeader*", + "full_name": "__main__.unpack_plain_packed_task.task_header", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 698, + "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" + } + ], + "type": "reference" + }, + "__main__.unpack_plain_packed_task.task_output": { + "cairo_type": "felt*", + "full_name": "__main__.unpack_plain_packed_task.task_output", + "references": [ + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 698, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 699, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp] + [fp + 1], felt*)" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.BOOTLOADER_VERSION": { + "type": "const", + "value": 0 + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "members": { + "bitwise": { + "cairo_type": "felt", + "offset": 4 + }, + "ec_op": { + "cairo_type": "felt", + "offset": 5 + }, + "ecdsa": { + "cairo_type": "felt", + "offset": 3 + }, + "keccak": { + "cairo_type": "felt", + "offset": 6 + }, + "output": { + "cairo_type": "felt", + "offset": 0 + }, + "pedersen": { + "cairo_type": "felt", + "offset": 1 + }, + "poseidon": { + "cairo_type": "felt", + "offset": 7 + }, + "range_check": { + "cairo_type": "felt", + "offset": 2 + }, + "range_check96": { + "cairo_type": "felt", + "offset": 8 + } + }, + "size": 9, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinList": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinList", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.PoseidonBuiltin": { + "destination": "starkware.cairo.common.builtin_poseidon.poseidon.PoseidonBuiltin", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader", + "members": { + "bootloader_version": { + "cairo_type": "felt", + "offset": 1 + }, + "builtin_list": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinList", + "offset": 4 + }, + "data_length": { + "cairo_type": "felt", + "offset": 0 + }, + "n_builtins": { + "cairo_type": "felt", + "offset": 3 + }, + "program_main": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash": { + "decorators": [], + "pc": 209, + "type": "function" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.Args": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.Args", + "members": { + "program_data_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "use_poseidon": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.ImplicitArgs": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.Return": { + "cairo_type": "(hash: felt)", + "type": "type_definition" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 1 + }, + "pc": 211, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash", + "references": [ + { + "ap_tracking_data": { + "group": 14, + "offset": 0 + }, + "pc": 219, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 15, + "offset": 0 + }, + "pc": 227, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 15, + "offset": 0 + }, + "pc": 227, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 14, + "offset": 0 + }, + "pc": 219, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task": { + "decorators": [], + "pc": 231, + "type": "function" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.Args": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.Args", + "members": { + "builtin_encodings": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 0 + }, + "builtin_instance_sizes": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 1 + }, + "use_poseidon": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ImplicitArgs": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ImplicitArgs", + "members": { + "builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 0 + }, + "self_range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.SIZEOF_LOCALS": { + "type": "const", + "value": 26 + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 235, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 239, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val", + "references": [ + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 275, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 249, + "value": "[cast(fp + 3, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 298, + "value": "cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.call_task": { + "pc": 272, + "type": "label" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 250, + "value": "[cast(fp + 4, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 237, + "value": "[cast(fp + 2, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size", + "references": [ + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 297, + "value": "[cast(fp + 25, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 240, + "value": "[cast([fp + (-7)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-3), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 240, + "value": "[cast([fp + (-7)] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 263, + "value": "[cast(fp + 6, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 1 + }, + "pc": 251, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp + 1, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 253, + "value": "[cast(fp + 5, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 237, + "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main", + "references": [ + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 252, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ret_pc_label": { + "pc": 273, + "type": "label" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 276, + "value": "[cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": { + "cairo_type": "(selected_encodings_end: felt*)", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret", + "references": [ + { + "ap_tracking_data": { + "group": 20, + "offset": 0 + }, + "pc": 285, + "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 296, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr", + "references": [ + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 276, + "value": "[cast(fp + 15, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.get_ap": { + "destination": "starkware.cairo.common.registers.get_ap", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.hash_chain": { + "destination": "starkware.cairo.common.hash_chain.hash_chain", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.inner_select_builtins": { + "destination": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.poseidon_hash_many": { + "destination": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.select_input_builtins": { + "destination": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.execute_task.validate_builtins": { + "destination": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.BuiltinData": { + "destination": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.PoseidonBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_task": { + "destination": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks": { + "decorators": [], + "pc": 396, + "type": "function" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.Args": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.Args", + "members": { + "builtin_encodings": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 0 + }, + "builtin_instance_sizes": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 1 + }, + "n_tasks": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.ImplicitArgs": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.ImplicitArgs", + "members": { + "builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "offset": 0 + }, + "self_range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 28, + "offset": 0 + }, + "pc": 410, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 29, + "offset": 0 + }, + "pc": 416, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 28, + "offset": 0 + }, + "pc": 410, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 29, + "offset": 0 + }, + "pc": 416, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon", + "references": [ + { + "ap_tracking_data": { + "group": 27, + "offset": 1 + }, + "pc": 403, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader": { + "decorators": [], + "pc": 302, + "type": "function" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.Args": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ImplicitArgs": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ImplicitArgs", + "members": { + "bitwise_ptr": { + "cairo_type": "felt", + "offset": 4 + }, + "ec_op_ptr": { + "cairo_type": "felt", + "offset": 5 + }, + "ecdsa_ptr": { + "cairo_type": "felt", + "offset": 3 + }, + "keccak_ptr": { + "cairo_type": "felt", + "offset": 6 + }, + "output_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 7 + }, + "range_check96_ptr": { + "cairo_type": "felt", + "offset": 8 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 9, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.SIZEOF_LOCALS": { + "type": "const", + "value": 29 + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "[cast(ap + (-2), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47", + "references": [ + { + "ap_tracking_data": { + "group": 23, + "offset": 1 + }, + "pc": 365, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks", + "references": [ + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "cast([[fp + 28] + 2] - [ap + (-1)], felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 4, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 332, + "value": "[cast(fp + 10, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 350, + "value": "[cast(fp + 19, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 362, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast(fp + 28, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": { + "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 314, + "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 5, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-8), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 3, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 6, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "[cast([fp + (-11)], felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-11), felt**)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "cast([fp + (-11)] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28], felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 8, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 2, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 362, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "[cast(fp, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative": { + "decorators": [], + "pc": 380, + "type": "function" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.Args": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.Args", + "members": { + "n_bits": { + "cairo_type": "felt", + "offset": 1 + }, + "num": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.ImplicitArgs": { + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48", + "references": [ + { + "ap_tracking_data": { + "group": 25, + "offset": 2 + }, + "pc": 388, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit", + "references": [ + { + "ap_tracking_data": { + "group": 25, + "offset": 3 + }, + "pc": 389, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits", + "references": [ + { + "ap_tracking_data": { + "group": 25, + "offset": 0 + }, + "pc": 380, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num", + "references": [ + { + "ap_tracking_data": { + "group": 25, + "offset": 0 + }, + "pc": 380, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": { + "cairo_type": "felt", + "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2", + "references": [ + { + "ap_tracking_data": { + "group": 25, + "offset": 1 + }, + "pc": 387, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins": { + "decorators": [], + "pc": 6, + "type": "function" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.Args": { + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.Args", + "members": { + "all_encodings": { + "cairo_type": "felt*", + "offset": 0 + }, + "all_ptrs": { + "cairo_type": "felt*", + "offset": 1 + }, + "n_builtins": { + "cairo_type": "felt", + "offset": 4 + }, + "selected_encodings": { + "cairo_type": "felt*", + "offset": 2 + }, + "selected_ptrs": { + "cairo_type": "felt*", + "offset": 3 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.FUNC_MEMORY_NO_BUILTINS": { + "type": "const", + "value": 1 + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.FUNC_MEMORY_WITH_BUILTINS": { + "type": "const", + "value": 10 + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.ImplicitArgs": { + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.Return": { + "cairo_type": "(selected_encodings_end: felt*)", + "type": "type_definition" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.SIZEOF_LOCALS": { + "type": "const", + "value": 3 + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-7), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-6), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 14, + "value": "[cast(fp + 1, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 15, + "value": "[cast(fp + 2, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 12, + "value": "[cast(fp, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-5), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.builtin_selection.select_input_builtins.inner_select_builtins": { + "destination": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins", + "type": "alias" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins": { + "decorators": [], + "pc": 32, + "type": "function" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.Args": { + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.Args", + "members": { + "all_encodings": { + "cairo_type": "felt*", + "offset": 0 + }, + "all_ptrs": { + "cairo_type": "felt*", + "offset": 1 + }, + "n_all_builtins": { + "cairo_type": "felt", + "offset": 2 + }, + "n_selected_builtins": { + "cairo_type": "felt", + "offset": 4 + }, + "selected_encodings": { + "cairo_type": "felt*", + "offset": 3 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.FUNC_MEMORY_WITHOUT_INNER_FUNC": { + "type": "const", + "value": 11 + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.INNER_FUNC_MEMORY_FINAL_ITERATION": { + "type": "const", + "value": 1 + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.INNER_FUNC_MEMORY_PER_ITERATION": { + "type": "const", + "value": 10 + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.ImplicitArgs": { + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 3 + }, + "pc": 36, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 4 + }, + "pc": 38, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-7), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-6), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": { + "cairo_type": "(fp_val: felt*, pc_val: felt*)", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 2 + }, + "pc": 34, + "value": "[cast(ap + (-2), (fp_val: felt*, pc_val: felt*)*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "cast([fp + (-5)] * 10 + 1, felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": { + "cairo_type": "(selected_encodings_end: felt*)", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret", + "references": [ + { + "ap_tracking_data": { + "group": 5, + "offset": 0 + }, + "pc": 45, + "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-5), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 2 + }, + "pc": 34, + "value": "cast([ap + (-2)] + [fp + (-5)] * 10 + 12, felt*)" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "cast([fp + (-5)] * 10 + 12, felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin": { + "decorators": [], + "pc": 48, + "type": "function" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.Args": { + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.Args", + "members": { + "builtin_instance_size": { + "cairo_type": "felt", + "offset": 2 + }, + "new_builtin_ptr": { + "cairo_type": "felt*", + "offset": 1 + }, + "prev_builtin_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.ImplicitArgs": { + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 1 + }, + "pc": 49, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 2 + }, + "pc": 50, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-5), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 2 + }, + "pc": 51, + "value": "cast([fp + (-6)] + 1, felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins": { + "decorators": [], + "pc": 54, + "type": "function" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.Args": { + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.Args", + "members": { + "builtin_instance_sizes": { + "cairo_type": "felt*", + "offset": 2 + }, + "n_builtins": { + "cairo_type": "felt", + "offset": 3 + }, + "new_builtin_ptrs": { + "cairo_type": "felt*", + "offset": 1 + }, + "prev_builtin_ptrs": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.ImplicitArgs": { + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-5), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-6), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 9 + }, + "pc": 64, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 9, + "offset": 0 + }, + "pc": 74, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.cairo_verifier.objects.CairoVerifierOutput": { + "full_name": "starkware.cairo.cairo_verifier.objects.CairoVerifierOutput", + "members": { + "output_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "program_hash": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.bool.FALSE": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.bool.TRUE": { + "type": "const", + "value": 1 + }, + "starkware.cairo.common.builtin_poseidon.poseidon.PoseidonBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", + "type": "alias" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.PoseidonBuiltinState": { + "destination": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "type": "alias" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many": { + "decorators": [], + "pc": 75, + "type": "function" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.Args": { + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.Args", + "members": { + "elements": { + "cairo_type": "felt*", + "offset": 1 + }, + "n": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.ImplicitArgs": { + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.ImplicitArgs", + "members": { + "poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.Return": { + "cairo_type": "(res: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 14 + }, + "pc": 101, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 15 + }, + "pc": 102, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 16 + }, + "pc": 103, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 105, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 18 + }, + "pc": 107, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 19 + }, + "pc": 108, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 20 + }, + "pc": 109, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 21 + }, + "pc": 111, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 22 + }, + "pc": 112, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 23 + }, + "pc": 113, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 6 + }, + "pc": 85, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 115, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 25 + }, + "pc": 117, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 26 + }, + "pc": 118, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 27 + }, + "pc": 119, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 28 + }, + "pc": 121, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 29 + }, + "pc": 122, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 30 + }, + "pc": 123, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 125, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 32 + }, + "pc": 127, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 33 + }, + "pc": 128, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 7 + }, + "pc": 90, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 34 + }, + "pc": 129, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 35 + }, + "pc": 131, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 36 + }, + "pc": 132, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 37 + }, + "pc": 133, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 135, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 7 + }, + "pc": 147, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 152, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 153, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 155, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 156, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 91, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 168, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 173, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 183, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 184, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 187, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 93, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 94, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 97, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 98, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 13 + }, + "pc": 99, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 4 + }, + "pc": 82, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 42 + }, + "pc": 141, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 15 + }, + "pc": 163, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "cast([fp + (-3)] + [fp + (-4)], felt*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.loop": { + "pc": 83, + "type": "label" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 169, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 5 + }, + "pc": 83, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 96, + "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 106, + "value": "cast([ap + (-13)] + 12, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 116, + "value": "cast([ap + (-20)] + 18, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 126, + "value": "cast([ap + (-27)] + 24, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 136, + "value": "cast([ap + (-34)] + 30, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 43 + }, + "pc": 143, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 158, + "value": "cast([ap + (-7)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 16 + }, + "pc": 165, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 176, + "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 189, + "value": "cast([ap + (-8)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 176, + "value": "[cast([ap + (-6)] + 3, felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 189, + "value": "[cast([ap + (-8)] + 3, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": { + "cairo_type": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 3 + }, + "pc": 81, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 96, + "value": "[cast([ap + (-6)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 106, + "value": "[cast([ap + (-13)] + 9, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 116, + "value": "[cast([ap + (-20)] + 15, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 126, + "value": "[cast([ap + (-27)] + 21, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 136, + "value": "[cast([ap + (-34)] + 27, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 41 + }, + "pc": 139, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 158, + "value": "[cast([ap + (-7)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 14 + }, + "pc": 161, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.cairo_builtins.BitwiseBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "x_and_y": { + "cairo_type": "felt", + "offset": 2 + }, + "x_or_y": { + "cairo_type": "felt", + "offset": 4 + }, + "x_xor_y": { + "cairo_type": "felt", + "offset": 3 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.EcOpBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.EcOpBuiltin", + "members": { + "m": { + "cairo_type": "felt", + "offset": 4 + }, + "p": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 0 + }, + "q": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 2 + }, + "r": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 5 + } + }, + "size": 7, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.EcPoint": { + "destination": "starkware.cairo.common.ec_point.EcPoint", + "type": "alias" + }, + "starkware.cairo.common.cairo_builtins.HashBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "members": { + "result": { + "cairo_type": "felt", + "offset": 2 + }, + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.KeccakBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.KeccakBuiltin", + "members": { + "input": { + "cairo_type": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "offset": 0 + }, + "output": { + "cairo_type": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "offset": 8 + } + }, + "size": 16, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.KeccakBuiltinState": { + "destination": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "type": "alias" + }, + "starkware.cairo.common.cairo_builtins.PoseidonBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", + "members": { + "input": { + "cairo_type": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "offset": 0 + }, + "output": { + "cairo_type": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "offset": 3 + } + }, + "size": 6, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.PoseidonBuiltinState": { + "destination": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "type": "alias" + }, + "starkware.cairo.common.cairo_builtins.SignatureBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", + "members": { + "message": { + "cairo_type": "felt", + "offset": 1 + }, + "pub_key": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.ec_point.EcPoint": { + "full_name": "starkware.cairo.common.ec_point.EcPoint", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.find_element.FIND_ELEMENT_RANGE_CHECK_USAGE": { + "type": "const", + "value": 2 + }, + "starkware.cairo.common.find_element.assert_le": { + "destination": "starkware.cairo.common.math.assert_le", + "type": "alias" + }, + "starkware.cairo.common.find_element.assert_le_felt": { + "destination": "starkware.cairo.common.math.assert_le_felt", + "type": "alias" + }, + "starkware.cairo.common.find_element.assert_lt_felt": { + "destination": "starkware.cairo.common.math.assert_lt_felt", + "type": "alias" + }, + "starkware.cairo.common.find_element.assert_nn_le": { + "destination": "starkware.cairo.common.math.assert_nn_le", + "type": "alias" + }, + "starkware.cairo.common.find_element.find_element": { + "decorators": [], + "pc": 435, + "type": "function" + }, + "starkware.cairo.common.find_element.find_element.Args": { + "full_name": "starkware.cairo.common.find_element.find_element.Args", + "members": { + "array_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "elm_size": { + "cairo_type": "felt", + "offset": 1 + }, + "key": { + "cairo_type": "felt", + "offset": 3 + }, + "n_elms": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.cairo.common.find_element.find_element.ImplicitArgs": { + "full_name": "starkware.cairo.common.find_element.find_element.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.find_element.find_element.Return": { + "cairo_type": "(elm_ptr: felt*)", + "type": "type_definition" + }, + "starkware.cairo.common.find_element.find_element.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "starkware.cairo.common.find_element.find_element.__temp49": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.__temp49", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 21 + }, + "pc": 444, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.array_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.find_element.find_element.array_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-6), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.elm_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.find_element.find_element.elm_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 22 + }, + "pc": 445, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.elm_size": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.elm_size", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-5), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.index": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.index", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 1 + }, + "pc": 437, + "value": "[cast(fp, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.key": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.key", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.n_elms": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.n_elms", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.find_element.find_element.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.find_element.find_element.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 20 + }, + "pc": 443, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.common.hash.hash2": { + "decorators": [], + "pc": 449, + "type": "function" + }, + "starkware.cairo.common.hash.hash2.Args": { + "full_name": "starkware.cairo.common.hash.hash2.Args", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash.hash2.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash.hash2.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash.hash2.Return": { + "cairo_type": "(result: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash.hash2.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.hash.hash2.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash.hash2.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 451, + "value": "cast([fp + (-5)] + 3, starkware.cairo.common.cairo_builtins.HashBuiltin*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash.hash2.result": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash.hash2.result", + "references": [ + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 451, + "value": "[cast([fp + (-5)] + 2, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash.hash2.x": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash.hash2.x", + "references": [ + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash.hash2.y": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash.hash2.y", + "references": [ + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.common.hash_chain.hash_chain": { + "decorators": [], + "pc": 193, + "type": "function" + }, + "starkware.cairo.common.hash_chain.hash_chain.Args": { + "full_name": "starkware.cairo.common.hash_chain.hash_chain.Args", + "members": { + "data_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_chain.hash_chain.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_chain.hash_chain.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_chain.hash_chain.LoopLocals": { + "full_name": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals", + "members": { + "cur_hash": { + "cairo_type": "felt", + "offset": 2 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_chain.hash_chain.Return": { + "cairo_type": "(hash: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_chain.hash_chain.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.hash_chain.hash_chain.curr_frame": { + "cairo_type": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals*", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.curr_frame", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.current_hash": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.current_hash", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.data_length": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.data_length", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 1 + }, + "pc": 194, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.data_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 0 + }, + "pc": 193, + "value": "[cast(fp + (-3), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 2 + }, + "pc": 195, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.hash_loop": { + "pc": 197, + "type": "label" + }, + "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 0 + }, + "pc": 193, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 9 + }, + "pc": 208, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.loop_frame": { + "cairo_type": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.loop_frame", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 5 + }, + "pc": 198, + "value": "[cast(ap, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.new_data": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.new_data", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 5 + }, + "pc": 198, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_chain.hash_chain.next_frame": { + "cairo_type": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals", + "full_name": "starkware.cairo.common.hash_chain.hash_chain.next_frame", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 9 + }, + "pc": 205, + "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.common.hash_state.HashState": { + "full_name": "starkware.cairo.common.hash_state.HashState", + "members": { + "current_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "n_words": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash_state.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.common.hash_state.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "starkware.cairo.common.hash_state.hash_felts": { + "decorators": [], + "pc": 512, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_felts.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_felts.Args", + "members": { + "data": { + "cairo_type": "felt*", + "offset": 0 + }, + "length": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_felts.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_felts.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_felts.Return": { + "cairo_type": "(hash: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_felts.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.hash_state.hash_felts.data": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_felts.data", + "references": [ + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_state.hash_felts.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 0 + }, + "pc": 520, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 9 + }, + "pc": 522, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "full_name": "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 40, + "offset": 7 + }, + "pc": 514, + "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 0 + }, + "pc": 520, + "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts.length": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts.length", + "references": [ + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding": { + "decorators": [], + "pc": 487, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.Args", + "members": { + "data_length": { + "cairo_type": "felt", + "offset": 1 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "initial_hash": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals": { + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals", + "members": { + "cur_hash": { + "cairo_type": "felt", + "offset": 2 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.Return": { + "cairo_type": "(hash: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 496, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 7 + }, + "pc": 503, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 497, + "value": "[cast(fp, felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-5), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.final_locals": { + "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.final_locals", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 10 + }, + "pc": 511, + "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": { + "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 497, + "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_loop": { + "pc": 500, + "type": "label" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 10 + }, + "pc": 511, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 6 + }, + "pc": 501, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": { + "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 7 + }, + "pc": 504, + "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": { + "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", + "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals", + "references": [ + { + "ap_tracking_data": { + "group": 39, + "offset": 5 + }, + "pc": 500, + "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_finalize": { + "decorators": [], + "pc": 481, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_finalize.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_finalize.Args", + "members": { + "hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_finalize.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_finalize.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_finalize.Return": { + "cairo_type": "(hash: felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_finalize.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.hash_state.hash_finalize.hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_finalize.hash", + "references": [ + { + "ap_tracking_data": { + "group": 38, + "offset": 7 + }, + "pc": 486, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_state.hash_finalize.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 38, + "offset": 0 + }, + "pc": 481, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 38, + "offset": 7 + }, + "pc": 486, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "full_name": "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 38, + "offset": 0 + }, + "pc": 481, + "value": "[cast(fp + (-3), starkware.cairo.common.hash_state.HashState**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_init": { + "decorators": [], + "pc": 455, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_init.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_init.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_init.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_init.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_init.Return": { + "cairo_type": "(hash_state_ptr: starkware.cairo.common.hash_state.HashState*)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_init.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.cairo.common.hash_state.hash_init.__fp__": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_init.__fp__", + "references": [ + { + "ap_tracking_data": { + "group": 35, + "offset": 4 + }, + "pc": 459, + "value": "[cast(ap + (-2), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_init.hash_state": { + "cairo_type": "starkware.cairo.common.hash_state.HashState", + "full_name": "starkware.cairo.common.hash_state.hash_init.hash_state", + "references": [ + { + "ap_tracking_data": { + "group": 35, + "offset": 4 + }, + "pc": 459, + "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update": { + "decorators": [], + "pc": 465, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_update.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_update.Args", + "members": { + "data_length": { + "cairo_type": "felt", + "offset": 2 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 1 + }, + "hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_update.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update.Return": { + "cairo_type": "(new_hash_state_ptr: starkware.cairo.common.hash_state.HashState*)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_update.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.cairo.common.hash_state.hash_update.__fp__": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_update.__fp__", + "references": [ + { + "ap_tracking_data": { + "group": 37, + "offset": 2 + }, + "pc": 475, + "value": "[cast(ap + (-2), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.__temp50": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_update.__temp50", + "references": [ + { + "ap_tracking_data": { + "group": 37, + "offset": 3 + }, + "pc": 477, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.data_length": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_update.data_length", + "references": [ + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.data_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.hash_state.hash_update.data_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.hash": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.hash_state.hash_update.hash", + "references": [ + { + "ap_tracking_data": { + "group": 37, + "offset": 0 + }, + "pc": 473, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "full_name": "starkware.cairo.common.hash_state.hash_update.hash_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 0 + }, + "pc": 473, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "full_name": "starkware.cairo.common.hash_state.hash_update.hash_state_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-5), starkware.cairo.common.hash_state.HashState**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.hash_state.hash_update.new_hash_state": { + "cairo_type": "starkware.cairo.common.hash_state.HashState", + "full_name": "starkware.cairo.common.hash_state.hash_update.new_hash_state", + "references": [ + { + "ap_tracking_data": { + "group": 37, + "offset": 2 + }, + "pc": 475, + "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.keccak_state.KeccakBuiltinState": { + "full_name": "starkware.cairo.common.keccak_state.KeccakBuiltinState", + "members": { + "s0": { + "cairo_type": "felt", + "offset": 0 + }, + "s1": { + "cairo_type": "felt", + "offset": 1 + }, + "s2": { + "cairo_type": "felt", + "offset": 2 + }, + "s3": { + "cairo_type": "felt", + "offset": 3 + }, + "s4": { + "cairo_type": "felt", + "offset": 4 + }, + "s5": { + "cairo_type": "felt", + "offset": 5 + }, + "s6": { + "cairo_type": "felt", + "offset": 6 + }, + "s7": { + "cairo_type": "felt", + "offset": 7 + } + }, + "size": 8, + "type": "struct" + }, + "starkware.cairo.common.math.FALSE": { + "destination": "starkware.cairo.common.bool.FALSE", + "type": "alias" + }, + "starkware.cairo.common.math.TRUE": { + "destination": "starkware.cairo.common.bool.TRUE", + "type": "alias" + }, + "starkware.cairo.common.math.assert_le": { + "decorators": [], + "pc": 421, + "type": "function" + }, + "starkware.cairo.common.math.assert_le.Args": { + "full_name": "starkware.cairo.common.math.assert_le.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + }, + "b": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.math.assert_le.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_le.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_le.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_le.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_le.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_le.a", + "references": [ + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_le.b": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_le.b", + "references": [ + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_le.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_le.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 31, + "offset": 5 + }, + "pc": 425, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_nn": { + "decorators": [], + "pc": 417, + "type": "function" + }, + "starkware.cairo.common.math.assert_nn.Args": { + "full_name": "starkware.cairo.common.math.assert_nn.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_nn.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_nn.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_nn.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_nn.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_nn.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn.a", + "references": [ + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 417, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_nn.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 417, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 418, + "value": "cast([fp + (-4)] + 1, felt)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_nn_le": { + "decorators": [], + "pc": 426, + "type": "function" + }, + "starkware.cairo.common.math.assert_nn_le.Args": { + "full_name": "starkware.cairo.common.math.assert_nn_le.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + }, + "b": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.math.assert_nn_le.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_nn_le.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_nn_le.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_nn_le.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_nn_le.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn_le.a", + "references": [ + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_nn_le.b": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn_le.b", + "references": [ + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_nn_le.range_check_ptr": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn_le.range_check_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 5 + }, + "pc": 430, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 14 + }, + "pc": 434, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy": { + "decorators": [], + "pc": 523, + "type": "function" + }, + "starkware.cairo.common.memcpy.memcpy.Args": { + "full_name": "starkware.cairo.common.memcpy.memcpy.Args", + "members": { + "dst": { + "cairo_type": "felt*", + "offset": 0 + }, + "len": { + "cairo_type": "felt", + "offset": 2 + }, + "src": { + "cairo_type": "felt*", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.ImplicitArgs": { + "full_name": "starkware.cairo.common.memcpy.memcpy.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.LoopFrame": { + "full_name": "starkware.cairo.common.memcpy.memcpy.LoopFrame", + "members": { + "dst": { + "cairo_type": "felt*", + "offset": 0 + }, + "src": { + "cairo_type": "felt*", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.memcpy.memcpy.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.memcpy.memcpy.__temp53": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.memcpy.memcpy.__temp53", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 529, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.continue_copying": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.memcpy.memcpy.continue_copying", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 530, + "value": "[cast(ap, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.dst": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.memcpy.memcpy.dst", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-5), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.frame": { + "cairo_type": "starkware.cairo.common.memcpy.memcpy.LoopFrame", + "full_name": "starkware.cairo.common.memcpy.memcpy.frame", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 2 + }, + "pc": 528, + "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 2 + }, + "pc": 528, + "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.len": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.memcpy.memcpy.len", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.loop": { + "pc": 528, + "type": "label" + }, + "starkware.cairo.common.memcpy.memcpy.next_frame": { + "cairo_type": "starkware.cairo.common.memcpy.memcpy.LoopFrame*", + "full_name": "starkware.cairo.common.memcpy.memcpy.next_frame", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 530, + "value": "cast(ap + 1, starkware.cairo.common.memcpy.memcpy.LoopFrame*)" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.src": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.common.memcpy.memcpy.src", + "references": [ + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-4), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.poseidon_state.PoseidonBuiltinState": { + "full_name": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", + "members": { + "s0": { + "cairo_type": "felt", + "offset": 0 + }, + "s1": { + "cairo_type": "felt", + "offset": 1 + }, + "s2": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.registers.get_ap": { + "destination": "starkware.cairo.lang.compiler.lib.registers.get_ap", + "type": "alias" + }, + "starkware.cairo.common.registers.get_fp_and_pc": { + "destination": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap": { + "decorators": [ + "known_ap_change" + ], + "pc": 1, + "type": "function" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.Args": { + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.ImplicitArgs": { + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.Return": { + "cairo_type": "(ap_val: felt*)", + "type": "type_definition" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val", + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 2 + }, + "pc": 3, + "value": "[cast(ap + (-2), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val": { + "cairo_type": "felt*", + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val", + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 2 + }, + "pc": 3, + "value": "[cast(ap + (-1), felt**)]" + } + ], + "type": "reference" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc": { + "decorators": [], + "pc": 0, + "type": "function" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Args": { + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.ImplicitArgs": { + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Return": { + "cairo_type": "(fp_val: felt*, pc_val: felt*)", + "type": "type_definition" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + } + }, + "main_scope": "__main__", + "prime": "0x800000000000011000000000000000000000000000000000000000000000001", + "reference_manager": { + "references": [ + { + "ap_tracking_data": { + "group": 1, + "offset": 2 + }, + "pc": 3, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 1, + "offset": 2 + }, + "pc": 3, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 6, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 12, + "value": "[cast(fp, felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 14, + "value": "[cast(fp + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 15, + "value": "[cast(fp + 2, felt*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "cast([fp + (-5)] * 10 + 1, felt)" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 32, + "value": "cast([fp + (-5)] * 10 + 12, felt)" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 2 + }, + "pc": 34, + "value": "[cast(ap + (-2), (fp_val: felt*, pc_val: felt*)*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 2 + }, + "pc": 34, + "value": "cast([ap + (-2)] + [fp + (-5)] * 10 + 12, felt*)" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 3 + }, + "pc": 36, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 4 + }, + "pc": 38, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 5, + "offset": 0 + }, + "pc": 45, + "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 0 + }, + "pc": 48, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 1 + }, + "pc": 49, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 2 + }, + "pc": 50, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 7, + "offset": 2 + }, + "pc": 51, + "value": "cast([fp + (-6)] + 1, felt)" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 54, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 9 + }, + "pc": 64, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 9, + "offset": 0 + }, + "pc": 74, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 75, + "value": "cast([fp + (-3)] + [fp + (-4)], felt*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 3 + }, + "pc": 81, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 4 + }, + "pc": 82, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 5 + }, + "pc": 83, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 6 + }, + "pc": 85, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 7 + }, + "pc": 90, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 91, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 93, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 94, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 96, + "value": "[cast([ap + (-6)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 96, + "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 97, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 98, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 13 + }, + "pc": 99, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 14 + }, + "pc": 101, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 15 + }, + "pc": 102, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 16 + }, + "pc": 103, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 105, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 106, + "value": "[cast([ap + (-13)] + 9, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 17 + }, + "pc": 106, + "value": "cast([ap + (-13)] + 12, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 18 + }, + "pc": 107, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 19 + }, + "pc": 108, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 20 + }, + "pc": 109, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 21 + }, + "pc": 111, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 22 + }, + "pc": 112, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 23 + }, + "pc": 113, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 115, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 116, + "value": "[cast([ap + (-20)] + 15, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 24 + }, + "pc": 116, + "value": "cast([ap + (-20)] + 18, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 25 + }, + "pc": 117, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 26 + }, + "pc": 118, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 27 + }, + "pc": 119, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 28 + }, + "pc": 121, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 29 + }, + "pc": 122, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 30 + }, + "pc": 123, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 125, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 126, + "value": "[cast([ap + (-27)] + 21, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 31 + }, + "pc": 126, + "value": "cast([ap + (-27)] + 24, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 32 + }, + "pc": 127, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 33 + }, + "pc": 128, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 34 + }, + "pc": 129, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 35 + }, + "pc": 131, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 36 + }, + "pc": 132, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 37 + }, + "pc": 133, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 135, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 136, + "value": "[cast([ap + (-34)] + 27, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 38 + }, + "pc": 136, + "value": "cast([ap + (-34)] + 30, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 41 + }, + "pc": 139, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 42 + }, + "pc": 141, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 43 + }, + "pc": 143, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 7 + }, + "pc": 147, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 152, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 153, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 155, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 156, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 158, + "value": "[cast([ap + (-7)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 158, + "value": "cast([ap + (-7)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 14 + }, + "pc": 161, + "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 15 + }, + "pc": 163, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 16 + }, + "pc": 165, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 141, + "value": "[cast(ap - 1 + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 143, + "value": "[cast(ap - 0 + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 139, + "value": "[cast(ap - 2 + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 8 + }, + "pc": 168, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 9 + }, + "pc": 169, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 173, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 176, + "value": "[cast([ap + (-6)] + 3, felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 176, + "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 10 + }, + "pc": 183, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 11 + }, + "pc": 184, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 187, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 189, + "value": "[cast([ap + (-8)] + 3, felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 12 + }, + "pc": 189, + "value": "cast([ap + (-8)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 0 + }, + "pc": 193, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 0 + }, + "pc": 193, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 1 + }, + "pc": 194, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 2 + }, + "pc": 195, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 4 + }, + "pc": 197, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 5 + }, + "pc": 198, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 5 + }, + "pc": 198, + "value": "[cast(ap, felt*)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 9 + }, + "pc": 205, + "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 9 + }, + "pc": 208, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 209, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 1 + }, + "pc": 211, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 14, + "offset": 0 + }, + "pc": 219, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 14, + "offset": 0 + }, + "pc": 219, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 15, + "offset": 0 + }, + "pc": 227, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 15, + "offset": 0 + }, + "pc": 227, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 231, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 235, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp + 1, felt**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 236, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 237, + "value": "[cast(fp + 2, felt*)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 28 + }, + "pc": 237, + "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 239, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 240, + "value": "[cast([fp + (-7)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 29 + }, + "pc": 240, + "value": "[cast([fp + (-7)] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-3), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 246, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 249, + "value": "[cast(fp + 3, felt**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 0 + }, + "pc": 250, + "value": "[cast(fp + 4, felt*)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 1 + }, + "pc": 251, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 252, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 253, + "value": "[cast(fp + 5, felt**)]" + }, + { + "ap_tracking_data": { + "group": 17, + "offset": 2 + }, + "pc": 263, + "value": "[cast(fp + 6, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + }, + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 275, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 276, + "value": "[cast(fp + 15, felt**)]" + }, + { + "ap_tracking_data": { + "group": 19, + "offset": 5 + }, + "pc": 276, + "value": "[cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + }, + { + "ap_tracking_data": { + "group": 20, + "offset": 0 + }, + "pc": 285, + "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" + }, + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 296, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 297, + "value": "[cast(fp + 25, felt*)]" + }, + { + "ap_tracking_data": { + "group": 21, + "offset": 0 + }, + "pc": 298, + "value": "cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-11), felt**)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-8), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 0 + }, + "pc": 302, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "[cast(fp, felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "[cast([fp + (-11)], felt*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 304, + "value": "cast([fp + (-11)] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 314, + "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 332, + "value": "[cast(fp + 10, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 29 + }, + "pc": 350, + "value": "[cast(fp + 19, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" + }, + { + "ap_tracking_data": { + "group": 22, + "offset": 31 + }, + "pc": 352, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 362, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 362, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast(fp + 28, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28], felt**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 2, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 3, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 4, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 5, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 6, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "[cast([fp + 28] + 8, felt*)]" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 0 + }, + "pc": 364, + "value": "cast([[fp + 28] + 2] - [ap + (-1)], felt)" + }, + { + "ap_tracking_data": { + "group": 23, + "offset": 1 + }, + "pc": 365, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 25, + "offset": 0 + }, + "pc": 380, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 25, + "offset": 0 + }, + "pc": 380, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 25, + "offset": 1 + }, + "pc": 387, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 25, + "offset": 2 + }, + "pc": 388, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 25, + "offset": 3 + }, + "pc": 389, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 0 + }, + "pc": 396, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 27, + "offset": 1 + }, + "pc": 403, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 28, + "offset": 0 + }, + "pc": 410, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 28, + "offset": 0 + }, + "pc": 410, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 29, + "offset": 0 + }, + "pc": 416, + "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" + }, + { + "ap_tracking_data": { + "group": 29, + "offset": 0 + }, + "pc": 416, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 417, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 417, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 30, + "offset": 0 + }, + "pc": 418, + "value": "cast([fp + (-4)] + 1, felt)" + }, + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 31, + "offset": 0 + }, + "pc": 421, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 31, + "offset": 5 + }, + "pc": 425, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 0 + }, + "pc": 426, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 5 + }, + "pc": 430, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 32, + "offset": 14 + }, + "pc": 434, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 0 + }, + "pc": 435, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 1 + }, + "pc": 437, + "value": "[cast(fp, felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 20 + }, + "pc": 443, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 21 + }, + "pc": 444, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 33, + "offset": 22 + }, + "pc": 445, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 449, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 451, + "value": "[cast([fp + (-5)] + 2, felt*)]" + }, + { + "ap_tracking_data": { + "group": 34, + "offset": 0 + }, + "pc": 451, + "value": "cast([fp + (-5)] + 3, starkware.cairo.common.cairo_builtins.HashBuiltin*)" + }, + { + "ap_tracking_data": { + "group": 35, + "offset": 4 + }, + "pc": 459, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 35, + "offset": 4 + }, + "pc": 459, + "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" + }, + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-5), starkware.cairo.common.hash_state.HashState**)]" + }, + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 36, + "offset": 0 + }, + "pc": 465, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 0 + }, + "pc": 473, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 0 + }, + "pc": 473, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 2 + }, + "pc": 475, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 2 + }, + "pc": 475, + "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" + }, + { + "ap_tracking_data": { + "group": 37, + "offset": 3 + }, + "pc": 477, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 38, + "offset": 0 + }, + "pc": 481, + "value": "[cast(fp + (-3), starkware.cairo.common.hash_state.HashState**)]" + }, + { + "ap_tracking_data": { + "group": 38, + "offset": 0 + }, + "pc": 481, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 38, + "offset": 7 + }, + "pc": 486, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 38, + "offset": 7 + }, + "pc": 486, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 0 + }, + "pc": 487, + "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 496, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 497, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 2 + }, + "pc": 497, + "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 5 + }, + "pc": 500, + "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 6 + }, + "pc": 501, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 7 + }, + "pc": 503, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 7 + }, + "pc": 504, + "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 10 + }, + "pc": 511, + "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" + }, + { + "ap_tracking_data": { + "group": 39, + "offset": 10 + }, + "pc": 511, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 40, + "offset": 0 + }, + "pc": 512, + "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 40, + "offset": 7 + }, + "pc": 514, + "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 0 + }, + "pc": 520, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 0 + }, + "pc": 520, + "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" + }, + { + "ap_tracking_data": { + "group": 41, + "offset": 9 + }, + "pc": 522, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 0 + }, + "pc": 523, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 2 + }, + "pc": 528, + "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 2 + }, + "pc": 528, + "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 529, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 530, + "value": "[cast(ap, felt*)]" + }, + { + "ap_tracking_data": { + "group": 42, + "offset": 3 + }, + "pc": 530, + "value": "cast(ap + 1, starkware.cairo.common.memcpy.memcpy.LoopFrame*)" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-11), felt**)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-9), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-8), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 0 + }, + "pc": 538, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 11 + }, + "pc": 540, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 43, + "offset": 11 + }, + "pc": 540, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 551, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 552, + "value": "[cast(fp + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 553, + "value": "[cast(fp + 2, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 554, + "value": "[cast(fp + 3, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 555, + "value": "[cast(fp + 4, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 556, + "value": "[cast(fp + 5, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 557, + "value": "[cast(fp + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 558, + "value": "[cast(fp + 7, felt*)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 559, + "value": "[cast(fp + 8, felt**)]" + }, + { + "ap_tracking_data": { + "group": 44, + "offset": 0 + }, + "pc": 559, + "value": "[cast(fp + 9, __main__.BootloaderConfig**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 564, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 564, + "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast(fp + 10, felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast([ap + (-2)] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "[cast([fp], felt*)]" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast([fp] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 45, + "offset": 0 + }, + "pc": 565, + "value": "cast(0, felt)" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 46, + "offset": 0 + }, + "pc": 578, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-4), __main__.BootloaderConfig**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-10), felt**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-9), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-7), felt*)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 0 + }, + "pc": 590, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 47, + "offset": 1 + }, + "pc": 603, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 48, + "offset": 0 + }, + "pc": 614, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 49, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 50, + "offset": 0 + }, + "pc": 625, + "value": "[cast(ap - 0 + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 51, + "offset": 0 + }, + "pc": 630, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + }, + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 52, + "offset": 0 + }, + "pc": 631, + "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 52, + "offset": 1 + }, + "pc": 632, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 638, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 638, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 53, + "offset": 0 + }, + "pc": 639, + "value": "cast([fp + (-5)] + 2, felt*)" + }, + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "[cast(fp + (-3), __main__.TaskOutputHeader**)]" + }, + { + "ap_tracking_data": { + "group": 54, + "offset": 0 + }, + "pc": 643, + "value": "cast([fp + (-3)] + 2, felt*)" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 0 + }, + "pc": 647, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 4 + }, + "pc": 649, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 55, + "offset": 4 + }, + "pc": 649, + "value": "[cast(fp + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 0 + }, + "pc": 654, + "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 0 + }, + "pc": 654, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 5 + }, + "pc": 657, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 5 + }, + "pc": 657, + "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 6 + }, + "pc": 659, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 37 + }, + "pc": 668, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 669, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 673, + "value": "[cast(fp + 2, felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "[cast(fp + 3, felt**)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "[cast([fp], felt*)]" + }, + { + "ap_tracking_data": { + "group": 56, + "offset": 38 + }, + "pc": 674, + "value": "cast([fp] + 1, felt*)" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-6), felt**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-2), felt*)]" + }, + { + "ap_tracking_data": { + "group": 57, + "offset": 0 + }, + "pc": 685, + "value": "[cast(ap + (-1), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-9), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-6), felt*)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-5), felt*)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 0 + }, + "pc": 693, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 698, + "value": "[cast(ap + (-2), felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 698, + "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 7 + }, + "pc": 699, + "value": "[cast(fp, felt**)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 8 + }, + "pc": 700, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 9 + }, + "pc": 702, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 9 + }, + "pc": 703, + "value": "cast([fp + (-9)] + 2, felt*)" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 10 + }, + "pc": 704, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 58, + "offset": 10 + }, + "pc": 706, + "value": "[cast(fp + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp + (-9)] + 2 + [fp + 1], felt*)" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp] + [fp + 1], felt*)" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 0 + }, + "pc": 712, + "value": "cast([fp + (-5)] + 1, felt)" + }, + { + "ap_tracking_data": { + "group": 59, + "offset": 1 + }, + "pc": 714, + "value": "[cast(ap + (-1), felt*)]" + } + ] + } +} diff --git a/src/hints/hint_processor.rs b/src/hints/hint_processor.rs index bb26763..141bb75 100644 --- a/src/hints/hint_processor.rs +++ b/src/hints/hint_processor.rs @@ -6,6 +6,7 @@ use cairo_vm::hint_processor::builtin_hint_processor::memcpy_hint_utils::exit_sc use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; use cairo_vm::types::exec_scope::ExecutionScopes; use cairo_vm::vm::errors::hint_errors::HintError; +use cairo_vm::vm::runners::cairo_runner::ResourceTracker; use cairo_vm::vm::vm_core::VirtualMachine; use cairo_vm::Felt252; @@ -31,6 +32,12 @@ use crate::hints::simple_bootloader_hints::{ pub struct BootloaderHintProcessor; +impl BootloaderHintProcessor { + pub fn new() -> Self { + Self {} + } +} + impl HintProcessorLogic for BootloaderHintProcessor { fn execute_hint( &mut self, @@ -113,3 +120,5 @@ impl HintProcessorLogic for BootloaderHintProcessor { } } } + +impl ResourceTracker for BootloaderHintProcessor {} diff --git a/src/lib.rs b/src/lib.rs index 5a49bee..6ad9a2d 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,5 +1,8 @@ use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::types::errors::program_errors::ProgramError; +use cairo_vm::types::exec_scope::ExecutionScopes; +use cairo_vm::types::program::Program; pub use hints::*; pub mod bootloaders; From 75ed509ab77f7a145805867c8f5af38e9e30ca51 Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Fri, 24 May 2024 15:40:11 +0200 Subject: [PATCH 09/28] example of fix --- src/hints/bootloader_hints.rs | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/src/hints/bootloader_hints.rs b/src/hints/bootloader_hints.rs index 4728b05..be5fb11 100644 --- a/src/hints/bootloader_hints.rs +++ b/src/hints/bootloader_hints.rs @@ -441,7 +441,9 @@ mod tests { use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_maybe_relocatable_from_var_name; use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; use cairo_vm::serde::deserialize_program::OffsetValue; - use cairo_vm::vm::runners::builtin_runner::{BuiltinRunner, OutputBuiltinState}; + use cairo_vm::vm::runners::builtin_runner::{ + BuiltinRunner, OutputBuiltinRunner, OutputBuiltinState, + }; use cairo_vm::vm::runners::cairo_pie::PublicMemoryPage; use cairo_vm::{any_box, relocatable, Felt252}; use rstest::{fixture, rstest}; @@ -469,9 +471,10 @@ mod tests { #[rstest] fn test_prepare_simple_bootloader_output_segment(bootloader_input: BootloaderInput) { - let mut vm = vm!(); - vm.segments.add(); - vm.run_context.fp = 1; + let mut vm = VirtualMachine::new(false); + vm.add_memory_segment(); + vm.add_memory_segment(); + vm.set_fp(1); let mut output_builtin = OutputBuiltinRunner::new(true); output_builtin.initialize_segments(&mut vm.segments); @@ -479,7 +482,10 @@ mod tests { .push(BuiltinRunner::Output(output_builtin.clone())); let mut exec_scopes = ExecutionScopes::new(); - let ids_data = ids_data!["simple_bootloader_output_start"]; + let ids_data = HashMap::from([( + "simple_bootloader_output_start".to_string(), + HintReference::new_simple(-1), + )]); let ap_tracking = ApTracking::new(); exec_scopes.insert_value(vars::BOOTLOADER_INPUT, bootloader_input); @@ -502,8 +508,6 @@ mod tests { // Check the content of the stored output builtin assert_ne!(current_output_builtin.base(), stored_output_builtin.base()); assert_eq!(stored_output_builtin.base(), output_builtin.base()); - assert_eq!(stored_output_builtin.stop_ptr, output_builtin.stop_ptr); - assert_eq!(stored_output_builtin.included, output_builtin.included); let simple_bootloader_output_start = get_maybe_relocatable_from_var_name( "simple_bootloader_output_start", From 051714b20a0a20b7c9dbd5aab5a5565ceb1264e5 Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Mon, 3 Jun 2024 18:40:37 +0300 Subject: [PATCH 10/28] fix: get tests compiling and running --- examples/run_program.rs | 100 -------------- src/hints/bootloader_hints.rs | 78 +++++------ src/hints/execute_task_hints.rs | 79 ++++++----- src/hints/inner_select_builtins.rs | 23 ++-- src/hints/program_loader.rs | 4 +- src/hints/select_builtins.rs | 14 +- src/hints/simple_bootloader_hints.rs | 36 ++--- src/lib.rs | 197 +++++++++++++++++++++++++++ 8 files changed, 308 insertions(+), 223 deletions(-) diff --git a/examples/run_program.rs b/examples/run_program.rs index ded0078..f451c0a 100644 --- a/examples/run_program.rs +++ b/examples/run_program.rs @@ -1,23 +1,10 @@ -<<<<<<< HEAD use std::error::Error; use cairo_vm::cairo_run::{cairo_run_program_with_initial_scope, CairoRunConfig}; -======= -use std::any::Any; -use std::collections::HashMap; -use std::error::Error; - -use cairo_vm::cairo_run::{cairo_run_program, CairoRunConfig}; -use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::{ - BuiltinHintProcessor, HintProcessorData, -}; -use cairo_vm::hint_processor::hint_processor_definition::{HintExtension, HintProcessorLogic}; ->>>>>>> fb2312f0f9bda782d4d08e8c6bb0bdf77f904ed8 use cairo_vm::types::exec_scope::ExecutionScopes; use cairo_vm::types::layout_name::LayoutName; use cairo_vm::types::program::Program; use cairo_vm::vm::errors::cairo_run_errors::CairoRunError; -<<<<<<< HEAD use cairo_vm::vm::runners::cairo_runner::CairoRunner; use cairo_vm::Felt252; @@ -28,86 +15,11 @@ use cairo_bootloader::{ PackedOutput, SimpleBootloaderInput, TaskSpec, }; -======= -use cairo_vm::vm::errors::hint_errors::HintError; -use cairo_vm::vm::runners::cairo_runner::{CairoRunner, ResourceTracker}; -use cairo_vm::vm::vm_core::VirtualMachine; -use cairo_vm::Felt252; -use starknet_types_core::felt::Felt; - -use cairo_bootloader::tasks::make_bootloader_tasks; -use cairo_bootloader::{ - insert_bootloader_input, load_bootloader, BootloaderConfig, BootloaderHintProcessor, - BootloaderInput, PackedOutput, SimpleBootloaderInput, TaskSpec, -}; - -struct ExampleHintProcessor { - bootloader_hint_processor: BootloaderHintProcessor, - builtin_hint_processor: BuiltinHintProcessor, -} - -impl ExampleHintProcessor { - fn new() -> Self { - Self { - bootloader_hint_processor: BootloaderHintProcessor {}, - builtin_hint_processor: BuiltinHintProcessor::new_empty(), - } - } -} - -impl HintProcessorLogic for ExampleHintProcessor { - fn execute_hint( - &mut self, - _vm: &mut VirtualMachine, - _exec_scopes: &mut ExecutionScopes, - hint_data: &Box, - _constants: &HashMap, - ) -> Result<(), HintError> { - // This method will never be called, but must be defined according to `HintProcessorLogic`. - - let hint_data = hint_data.downcast_ref::().unwrap(); - let hint_code = &hint_data.code; - Err(HintError::UnknownHint(hint_code.clone().into_boxed_str())) - } - - fn execute_hint_extensive( - &mut self, - vm: &mut VirtualMachine, - exec_scopes: &mut ExecutionScopes, - hint_data: &Box, - constants: &HashMap, - ) -> Result { - // Cascade through the internal hint processors until we find the hint implementation. - - match self.bootloader_hint_processor.execute_hint_extensive( - vm, - exec_scopes, - hint_data, - constants, - ) { - Err(HintError::UnknownHint(_)) => {} - result => { - return result; - } - } - - self.builtin_hint_processor - .execute_hint_extensive(vm, exec_scopes, hint_data, constants) - } -} - -impl ResourceTracker for ExampleHintProcessor {} - ->>>>>>> fb2312f0f9bda782d4d08e8c6bb0bdf77f904ed8 fn cairo_run_bootloader_in_proof_mode( bootloader_program: &Program, tasks: Vec, ) -> Result { -<<<<<<< HEAD let mut hint_processor = BootloaderHintProcessor::new(); -======= - let mut hint_processor = ExampleHintProcessor::new(); ->>>>>>> fb2312f0f9bda782d4d08e8c6bb0bdf77f904ed8 let cairo_run_config = CairoRunConfig { entrypoint: "main", @@ -141,19 +53,11 @@ fn cairo_run_bootloader_in_proof_mode( insert_bootloader_input(&mut exec_scopes, bootloader_input); // Run the bootloader -<<<<<<< HEAD cairo_run_program_with_initial_scope( &bootloader_program, &cairo_run_config, &mut hint_processor, exec_scopes, -======= - cairo_run_program( - &bootloader_program, - &cairo_run_config, - &mut hint_processor, - Some(exec_scopes), ->>>>>>> fb2312f0f9bda782d4d08e8c6bb0bdf77f904ed8 ) } @@ -163,15 +67,11 @@ fn main() -> Result<(), Box> { let tasks = make_bootloader_tasks(&[fibonacci_program], &[])?; -<<<<<<< HEAD let mut runner = cairo_run_bootloader_in_proof_mode(&bootloader_program, tasks)?; let mut output_buffer = "Program Output:\n".to_string(); runner.vm.write_output(&mut output_buffer)?; print!("{output_buffer}"); -======= - let _runner = cairo_run_bootloader_in_proof_mode(&bootloader_program, tasks)?; ->>>>>>> fb2312f0f9bda782d4d08e8c6bb0bdf77f904ed8 Ok(()) } diff --git a/src/hints/bootloader_hints.rs b/src/hints/bootloader_hints.rs index be5fb11..091ba2a 100644 --- a/src/hints/bootloader_hints.rs +++ b/src/hints/bootloader_hints.rs @@ -433,7 +433,11 @@ pub fn assert_program_address( mod tests { use num_traits::ToPrimitive; + use crate::hints::codes::{ + BOOTLOADER_GUESS_PRE_IMAGE_OF_SUBTASKS_OUTPUT_HASH, BOOTLOADER_SAVE_OUTPUT_POINTER, BOOTLOADER_SAVE_PACKED_OUTPUTS, BOOTLOADER_SET_PACKED_OUTPUT_TO_SUBTASKS, EXECUTE_TASK_ASSERT_PROGRAM_ADDRESS + }; use crate::hints::types::{BootloaderConfig, SimpleBootloaderInput}; + use crate::{add_segments, define_segments, ids_data, run_hint, segments, vm, MinimalBootloaderHintProcessor}; use assert_matches::assert_matches; use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::{ BuiltinHintProcessor, HintProcessorData, @@ -498,7 +502,7 @@ mod tests { .expect("Hint failed unexpectedly"); let current_output_builtin = vm - .get_output_builtin() + .get_output_builtin_mut() .expect("The VM should have an output builtin") .clone(); let stored_output_builtin: OutputBuiltinState = exec_scopes @@ -506,8 +510,8 @@ mod tests { .expect("The output builtin is not stored in the execution scope as expected"); // Check the content of the stored output builtin - assert_ne!(current_output_builtin.base(), stored_output_builtin.base()); - assert_eq!(stored_output_builtin.base(), output_builtin.base()); + assert_ne!(current_output_builtin.base(), stored_output_builtin.base); + assert_eq!(stored_output_builtin.base, output_builtin.base()); let simple_bootloader_output_start = get_maybe_relocatable_from_var_name( "simple_bootloader_output_start", @@ -561,12 +565,12 @@ mod tests { let mut vm: VirtualMachine = vm!(); // The VM must have an existing output segment let output_segment = vm.add_memory_segment(); - vm.builtin_runners = vec![OutputBuiltinRunner::from_segment(&output_segment, true).into()]; + vm.builtin_runners = vec![OutputBuiltinRunner::new(true).into()]; let mut exec_scopes = ExecutionScopes::new(); let new_segment = vm.add_memory_segment(); let output_builtin_state = OutputBuiltinState { - base: new_segment.segment_index, + base: new_segment.segment_index.try_into().unwrap(), pages: Default::default(), attributes: Default::default(), }; @@ -577,7 +581,7 @@ mod tests { assert_eq!(vm.builtin_runners.len(), 1); match &vm.builtin_runners[0] { BuiltinRunner::Output(output_builtin) => { - assert_eq!(output_builtin.base(), output_builtin_state.base()); + assert_eq!(output_builtin.base(), output_builtin_state.base); } other => panic!("Expected an output builtin, found {:?}", other), } @@ -589,7 +593,7 @@ mod tests { let mut vm = vm!(); add_segments!(vm, 2); - vm.run_context.fp = 2; + vm.set_fp(2); let mut exec_scopes = ExecutionScopes::new(); let ids_data = ids_data!["bootloader_config"]; @@ -602,10 +606,7 @@ mod tests { let bootloader_config_segment = get_ptr_from_var_name("bootloader_config", &mut vm, &ids_data, &ap_tracking).unwrap(); - let config_segment = vm - .segments - .memory .get_continuous_range(bootloader_config_segment, 3) .unwrap(); @@ -626,8 +627,6 @@ mod tests { match programs_segment { MaybeRelocatable::RelocatableValue(relocatable) => { let program_hashes: Vec = vm - .segments - .memory .get_integer_range(relocatable.clone(), expected_nb_programs) .unwrap() .iter() @@ -647,6 +646,7 @@ mod tests { #[rstest] fn test_gen_arg() { + use std::ops::Add; let mut vm = vm!(); let mut nested_args = Vec::>::new(); @@ -661,8 +661,6 @@ mod tests { let args_base: Relocatable = gen_arg(&mut vm, &args).expect("gen_args failed unexpectedly"); let values = vm - .segments - .memory .get_integer_range(args_base, 2) .expect("Loading values failed"); @@ -671,14 +669,10 @@ mod tests { let nested_args_address: Relocatable = args_base.add(2i32).unwrap(); let nested_args_base = vm - .segments - .memory .get_relocatable(nested_args_address) .expect("Nested vector should be here"); let nested_values = vm - .segments - .memory .get_integer_range(nested_args_base, 2) .expect("Loading nested values failed"); @@ -690,8 +684,8 @@ mod tests { fn test_enter_packed_output_scope() { let mut vm = vm!(); // Set n_subtasks to 2 - vm.run_context.fp = 1; - vm.segments = segments![((1, 0), 2)]; + vm.set_fp(1); + define_segments!(vm, 2, [((1, 0), 2)]); let ids_data = ids_data!["n_subtasks"]; let ap_tracking = ApTracking::default(); @@ -733,11 +727,7 @@ mod tests { ) -> bool { exec_scopes.insert_value(vars::PACKED_OUTPUT, packed_output); is_plain_packed_output(vm, exec_scopes).expect("Hint failed unexpectedly"); - let result = vm - .segments - .memory - .get_integer(vm.run_context.get_ap()) - .unwrap(); + let result = vm.get_integer(vm.get_ap()).unwrap(); result.into_owned() != Felt252::from(0) } @@ -748,7 +738,8 @@ mod tests { assert!(is_plain(&mut vm, &mut exec_scopes, plain_packed_output)); // Increment AP to avoid an inconsistent memory error writing in the same slot - vm.run_context.ap += 1; + let new_ap = (*&vm.get_ap() + 1usize).unwrap(); + vm.set_ap(new_ap.offset); assert!(!is_plain( &mut vm, &mut exec_scopes, @@ -759,18 +750,16 @@ mod tests { #[test] fn test_save_output_pointer() { let mut vm = vm!(); - vm.segments = segments![((1, 0), (0, 0))]; + define_segments!(vm, 2, [((1, 0), (0, 0))]); let mut hint_ref = HintReference::new(0, 0, true, false); hint_ref.offset2 = OffsetValue::Value(2); let ids_data = HashMap::from([("output_ptr".to_string(), hint_ref)]); let mut exec_scopes = ExecutionScopes::new(); - let hint_data = HintProcessorData::new_default( - String::from(hint_code::BOOTLOADER_SAVE_OUTPUT_POINTER), - ids_data, - ); - let mut hint_processor = BuiltinHintProcessor::new_empty(); + let hint_data = + HintProcessorData::new_default(String::from(BOOTLOADER_SAVE_OUTPUT_POINTER), ids_data); + let mut hint_processor = MinimalBootloaderHintProcessor::new(); assert_matches!( hint_processor.execute_hint( &mut vm, @@ -815,10 +804,10 @@ mod tests { exec_scopes.insert_box("bootloader_input", Box::new(bootloader_input.clone())); let hint_data = HintProcessorData::new_default( - String::from(hint_code::BOOTLOADER_SAVE_PACKED_OUTPUTS), + String::from(BOOTLOADER_SAVE_PACKED_OUTPUTS), HashMap::new(), ); - let mut hint_processor = BuiltinHintProcessor::new_empty(); + let mut hint_processor = MinimalBootloaderHintProcessor::new(); assert_matches!( hint_processor.execute_hint( &mut vm, @@ -881,8 +870,13 @@ mod tests { offset: 18 } ); + let pages = match vm.get_output_builtin_mut().unwrap().get_additional_data() { + cairo_vm::vm::runners::cairo_pie::BuiltinAdditionalData::Output(o) => o.pages, + _ => unreachable!("Type should be Output"), + }; + assert_eq!( - vm.get_output_builtin().unwrap().pages, + pages, HashMap::from([ (1, PublicMemoryPage { start: 2, size: 3 }), (2, PublicMemoryPage { start: 5, size: 1 }), @@ -909,10 +903,10 @@ mod tests { ); let hint_data = HintProcessorData::new_default( - String::from(hint_code::BOOTLOADER_SET_PACKED_OUTPUT_TO_SUBTASKS), + String::from(BOOTLOADER_SET_PACKED_OUTPUT_TO_SUBTASKS), HashMap::new(), ); - let mut hint_processor = BuiltinHintProcessor::new_empty(); + let mut hint_processor = MinimalBootloaderHintProcessor::new(); assert_matches!( hint_processor.execute_hint( &mut vm, @@ -931,7 +925,7 @@ mod tests { fn test_guess_pre_image_of_subtasks_output_hash() { let mut vm = vm!(); add_segments!(vm, 2); - vm.run_context.fp = 2; + vm.set_fp(2); let ids_data = ids_data!["nested_subtasks_output_len", "nested_subtasks_output"]; @@ -951,7 +945,7 @@ mod tests { run_hint!( vm, ids_data.clone(), - hint_code::BOOTLOADER_GUESS_PRE_IMAGE_OF_SUBTASKS_OUTPUT_HASH, + BOOTLOADER_GUESS_PRE_IMAGE_OF_SUBTASKS_OUTPUT_HASH, &mut exec_scopes ), Ok(()) @@ -959,7 +953,7 @@ mod tests { let nested_subtasks_output_len = get_integer_from_var_name("nested_subtasks_output_len", &vm, &ids_data, &ap_tracking) .expect("nested_subtasks_output_len should be set") - .into_owned(); + .to_owned(); assert_eq!(nested_subtasks_output_len, 1.into()); let nested_subtasks_output = @@ -992,7 +986,7 @@ mod tests { let mut vm = vm!(); add_segments!(vm, 2); - vm.run_context.fp = 2; + vm.set_fp(2); let ids_data = ids_data!(vars::PROGRAM_ADDRESS); let ap_tracking = ApTracking::new(); @@ -1023,7 +1017,7 @@ mod tests { let result = run_hint!( vm, ids_data.clone(), - hint_code::EXECUTE_TASK_ASSERT_PROGRAM_ADDRESS, + EXECUTE_TASK_ASSERT_PROGRAM_ADDRESS, &mut exec_scopes ); diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index 63423a2..73321be 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -493,14 +493,19 @@ mod tests { }; use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_maybe_relocatable_from_var_name; use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; - use cairo_vm::serde::deserialize_program::OffsetValue; + use cairo_vm::serde::deserialize_program::{OffsetValue, ReferenceManager}; + use cairo_vm::types::errors::math_errors::MathError; + use cairo_vm::types::program::Program; + use cairo_vm::types::relocatable::MaybeRelocatable; use cairo_vm::vm::runners::builtin_runner::BuiltinRunner; - use cairo_vm::vm::runners::cairo_pie::PublicMemoryPage; + use cairo_vm::vm::runners::cairo_pie::{BuiltinAdditionalData, OutputBuiltinAdditionalData, PublicMemoryPage}; use cairo_vm::{any_box, relocatable, Felt252}; use num_traits::ToPrimitive; use rstest::{fixture, rstest}; + use crate::hints::codes::EXECUTE_TASK_CALL_TASK; use crate::hints::types::{BootloaderConfig, SimpleBootloaderInput}; + use crate::{add_segments, define_segments, ids_data, non_continuous_ids_data, run_hint, segments, vm}; use super::*; @@ -508,7 +513,7 @@ mod tests { fn test_allocate_program_data_segment() { let mut vm = vm!(); // Allocate space for program_data_ptr - vm.run_context.fp = 1; + vm.set_fp(1); add_segments!(vm, 2); let ids_data = ids_data!["program_data_ptr"]; let expected_program_data_segment_index = vm.segments.num_segments(); @@ -545,7 +550,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../../../../../cairo_programs/fibonacci.json").to_vec(); + include_bytes!("../cairo-programs/fibonacci.json").to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") @@ -554,14 +559,14 @@ mod tests { #[fixture] fn fibonacci_pie() -> CairoPie { let pie_file = - Path::new("../cairo_programs/manually_compiled/fibonacci_cairo_pie/fibonacci_pie.zip"); - CairoPie::from_file(pie_file).expect("Failed to load the program PIE") + Path::new("../cairo-programs/pie.zip"); + CairoPie::read_zip_file(pie_file).expect("Failed to load the program PIE") } #[fixture] fn field_arithmetic_program() -> Program { let program_content = - include_bytes!("../../../../../cairo_programs/field_arithmetic.json").to_vec(); + include_bytes!("../cairo-programs/fibonacci.json").to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") @@ -572,9 +577,9 @@ mod tests { let task = Task::Program(fibonacci.clone()); let mut vm = vm!(); - vm.run_context.fp = 1; + vm.set_fp(1); // Set program_header_ptr to (2, 0) - vm.segments = segments![((1, 0), (2, 0))]; + define_segments!(vm, 2, [((1, 0), (2, 0))]); let program_header_ptr = Relocatable::from((2, 0)); add_segments!(vm, 1); @@ -593,13 +598,14 @@ mod tests { // The Fibonacci program has no builtins -> the header size is 4 let header_size = 4; - let expected_code_address = &program_header_ptr + header_size; + let code_address: Result = *&program_header_ptr + header_size; + let expected_code_address: Relocatable = code_address.unwrap(); let program_address: Relocatable = exec_scopes.get(vars::PROGRAM_ADDRESS).unwrap(); assert_eq!(program_address, expected_code_address); // Check that the segment was finalized - let expected_program_size = header_size + fibonacci.shared_program_data.data.len(); + let expected_program_size = header_size + fibonacci.data_len(); assert_eq!( vm.segments.segment_sizes[&(program_address.segment_index as usize)], expected_program_size @@ -612,8 +618,8 @@ mod tests { // Allocate space for pre-execution (8 felts), which mimics the `BuiltinData` struct in the // Bootloader's Cairo code. Our code only uses the first felt (`output` field in the struct) - vm.segments = segments![((1, 0), (2, 0))]; - vm.run_context.fp = 8; + define_segments!(vm, 2, [((1, 0), (2, 0))]); + vm.set_fp(8); add_segments!(vm, 1); let ids_data = non_continuous_ids_data![(vars::PRE_EXECUTION_BUILTIN_PTRS, -8)]; @@ -632,7 +638,7 @@ mod tests { run_hint!( vm, ids_data.clone(), - hint_code::EXECUTE_TASK_CALL_TASK, + EXECUTE_TASK_CALL_TASK, &mut exec_scopes ), Ok(()) @@ -662,15 +668,16 @@ mod tests { }) .collect(); - let shared_program_data = SharedProgramData { + let program = Program::new( + vec![], + Default::default(), + Default::default(), + Default::default(), + ReferenceManager::default(), identifiers, - ..Default::default() - }; - let program = Program { - shared_program_data: Arc::new(shared_program_data), - constants: Default::default(), - builtins: vec![], - }; + Default::default(), + Default::default(), + ).unwrap(); program } @@ -684,9 +691,9 @@ mod tests { // the Bootloader Cairo code. Our code only uses the first felt (`output` field in the // struct). Finally, we put the mocked output of `select_input_builtins` in the next // memory address and increase the AP register accordingly. - vm.segments = segments![((1, 0), (2, 0)), ((1, 1), (4, 0)), ((1, 9), (4, 42))]; - vm.run_context.ap = 10; - vm.run_context.fp = 9; + define_segments!(vm, 3, [((1, 0), (2, 0)), ((1, 1), (4, 0)), ((1, 9), (4, 42))]); + vm.set_ap(10); + vm.set_fp(9); add_segments!(vm, 3); let program_header_ptr = Relocatable::from((2, 0)); @@ -734,18 +741,18 @@ mod tests { // The pre-execution struct starts at (1, 0) and the return struct at (1, 8). // We only set the output values to (2, 0) and (2, 10), respectively, to get an output size // of 10. - vm.segments = segments![((1, 0), (2, 0)), ((1, 8), (2, 10)),]; - vm.run_context.fp = 16; + define_segments!(vm, 2, [((1, 0), (2, 0)), ((1, 8), (2, 10)),]); + vm.set_fp(16); add_segments!(vm, 1); let tree_structure = vec![1, 2, 3, 4]; - let program_output_data = OutputBuiltinAdditionalData { - base: 0, + let program_output_data = OutputBuiltinState { pages: HashMap::from([ (1, PublicMemoryPage { start: 0, size: 7 }), (2, PublicMemoryPage { start: 7, size: 3 }), ]), attributes: HashMap::from([("gps_fact_topology".to_string(), tree_structure.clone())]), + base: 0 }; let mut output_builtin = OutputBuiltinRunner::new(true); output_builtin.set_state(program_output_data.clone()); @@ -763,7 +770,6 @@ mod tests { let mut exec_scopes = ExecutionScopes::new(); let output_runner_data = OutputBuiltinAdditionalData { - base: 0, pages: HashMap::new(), attributes: HashMap::new(), }; @@ -783,7 +789,8 @@ mod tests { assert_eq!(fact_topology.tree_structure, tree_structure); // Check that the output builtin was updated - let output_builtin_additional_data = vm.get_output_builtin().unwrap().get_additional_data(); + let output_builtin_additional_data = + vm.get_output_builtin_mut().unwrap().get_additional_data(); assert!(matches!( output_builtin_additional_data, BuiltinAdditionalData::Output(data) if data == output_runner_data, @@ -802,7 +809,7 @@ mod tests { // Initialize the used builtins to {range_check: 30, bitwise: 50} as these two // are used by the field arithmetic program. Note that the used builtins list // does not contain empty elements (i.e. offsets are 8 and 9 instead of 10 and 12). - vm.segments = segments![ + define_segments!(vm, 2, [ ((1, 0), (2, 1)), ((1, 1), (2, 2)), ((1, 2), (2, 3)), @@ -814,8 +821,8 @@ mod tests { ((1, 8), (2, 30)), ((1, 9), (2, 50)), ((1, 24), (1, 8)), - ]; - vm.run_context.fp = 25; + ]); + vm.set_fp(25); add_segments!(vm, 1); // Note that used_builtins_addr is a pointer to the used builtins list at (1, 8) @@ -827,7 +834,7 @@ mod tests { let ap_tracking = ApTracking::new(); let mut exec_scopes = ExecutionScopes::new(); - let n_builtins = field_arithmetic_program.builtins.len(); + let n_builtins = field_arithmetic_program.builtins_len(); exec_scopes.insert_value(vars::N_BUILTINS, n_builtins); exec_scopes.insert_value(vars::TASK, task); @@ -836,8 +843,6 @@ mod tests { // Check that the return builtins were written correctly let return_builtins = vm - .segments - .memory .get_continuous_range(Relocatable::from((1, 16)), 8) .expect("Return builtin was not properly written to memory."); diff --git a/src/hints/inner_select_builtins.rs b/src/hints/inner_select_builtins.rs index e6936fa..50397bf 100644 --- a/src/hints/inner_select_builtins.rs +++ b/src/hints/inner_select_builtins.rs @@ -65,6 +65,8 @@ mod tests { use cairo_vm::Felt252; use rstest::rstest; + use crate::{add_segments, define_segments, ids_data, segments, vm}; + use super::*; #[rstest] @@ -81,16 +83,21 @@ mod tests { builtin_value + 1 }; - vm.segments = segments![ - ((1, 0), (2, 0)), - ((1, 1), (2, 1)), - ((2, 0), builtin_value), - ((2, 1), expected_value) - ]; + define_segments!( + vm, + 3, + [ + ((1, 0), (2, 0)), + ((1, 1), (2, 1)), + ((2, 0), builtin_value), + ((2, 1), expected_value) + ] + ); // Allocate space for program_data_ptr - vm.run_context.fp = 3; + vm.set_fp(3); add_segments!(vm, 2); let ids_data = ids_data!["selected_encodings", "all_encodings", "select_builtin"]; + // dbg!(&ids_data); let ap_tracking = ApTracking::new(); let mut exec_scopes = ExecutionScopes::new(); @@ -102,7 +109,7 @@ mod tests { let select_builtin = get_integer_from_var_name("select_builtin", &vm, &ids_data, &ap_tracking) .unwrap() - .into_owned(); + .to_owned(); let n_selected_builtins: usize = exec_scopes.get(vars::N_SELECTED_BUILTINS).unwrap(); if (n_builtins != 0) && should_select_builtin { diff --git a/src/hints/program_loader.rs b/src/hints/program_loader.rs index e36e178..c53328b 100644 --- a/src/hints/program_loader.rs +++ b/src/hints/program_loader.rs @@ -242,7 +242,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../../../../../cairo_programs/fibonacci.json").to_vec(); + include_bytes!("../cairo-programs/fibonacci.json").to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") @@ -295,7 +295,7 @@ mod tests { check_loaded_header(&vm, base_address.clone(), &program, bootloader_version); - let builtin_list_ptr = (base_address + builtins_offset)?; + let builtin_list_ptr = (base_address + builtins_offset).unwrap(); check_loaded_builtins(&vm, &vec![], builtin_list_ptr); } diff --git a/src/hints/select_builtins.rs b/src/hints/select_builtins.rs index dcb2666..1f74203 100644 --- a/src/hints/select_builtins.rs +++ b/src/hints/select_builtins.rs @@ -39,17 +39,13 @@ pub fn select_builtins_enter_scope( #[cfg(test)] mod tests { - use std::any::Any; - use std::collections::HashMap; - use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_integer_from_var_name; - use cairo_vm::hint_processor::hint_processor_definition::HintReference; use cairo_vm::serde::deserialize_program::ApTracking; use cairo_vm::types::exec_scope::ExecutionScopes; - use cairo_vm::vm::errors::hint_errors::HintError; use cairo_vm::vm::vm_core::VirtualMachine; - use num_traits::ToPrimitive; - use serde::Serialize; + use std::collections::HashMap; + + use crate::{define_segments, ids_data, segments, vm}; use super::*; @@ -57,8 +53,8 @@ mod tests { fn test_select_builtins_enter_scope() { let mut vm = vm!(); // Set n_selected_builtins to 7 - vm.run_context.fp = 1; - vm.segments = segments![((1, 0), 7)]; + vm.set_fp(1); + define_segments!(vm, 2, [((1, 0), 7)]); let ids_data = ids_data![vars::N_SELECTED_BUILTINS]; let n_selected_builtins = 7usize; diff --git a/src/hints/simple_bootloader_hints.rs b/src/hints/simple_bootloader_hints.rs index c473226..acdee27 100644 --- a/src/hints/simple_bootloader_hints.rs +++ b/src/hints/simple_bootloader_hints.rs @@ -131,15 +131,12 @@ pub fn set_current_task( #[cfg(test)] mod tests { - use std::any::Any; - use std::collections::HashMap; use std::collections::HashMap; use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{ get_ptr_from_var_name, get_relocatable_from_var_name, insert_value_from_var_name, }; - use cairo_vm::hint_processor::hint_processor_definition::HintReference; - use cairo_vm::serde::deserialize_program::{ApTracking, BuiltinName, Identifier}; + use cairo_vm::serde::deserialize_program::ApTracking; use cairo_vm::types::exec_scope::ExecutionScopes; use cairo_vm::types::program::Program; use cairo_vm::types::relocatable::{MaybeRelocatable, Relocatable}; @@ -153,7 +150,6 @@ mod tests { use cairo_vm::vm::vm_memory::memory::Memory; use cairo_vm::{any_box, Felt252}; use num_traits::ToPrimitive; - use num_traits::ToPrimitive; use rstest::{fixture, rstest}; use starknet_crypto::FieldElement; @@ -163,13 +159,14 @@ mod tests { use crate::hints::program_loader::ProgramLoader; use crate::hints::types::{BootloaderVersion, Task, TaskSpec}; use crate::hints::vars; + use crate::{add_segments, define_segments, ids_data, vm}; use super::*; #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../../../../../cairo_programs/fibonacci.json").to_vec(); + include_bytes!("../cairo-programs/fibonacci.json").to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") @@ -194,8 +191,8 @@ mod tests { #[rstest] fn test_prepare_task_range_checks(simple_bootloader_input: SimpleBootloaderInput) { let mut vm = vm!(); - vm.run_context.fp = 3; - vm.segments = segments![((1, 0), (2, 0)), ((1, 1), (2, 2))]; + vm.set_fp(3); + define_segments!(vm, 2, [((1, 0), (2, 0)), ((1, 1), (2, 2))]); let ids_data = ids_data!["output_ptr", "range_check_ptr", "task_range_check_ptr"]; vm.add_memory_segment(); @@ -216,8 +213,6 @@ mod tests { // Assert *output_ptr == n_tasks let output = vm - .segments - .memory .get_integer(Relocatable { segment_index: 2, offset: 0, @@ -266,8 +261,8 @@ mod tests { let mut vm = vm!(); add_segments!(vm, 2); - vm.run_context.ap = 1; - vm.run_context.fp = 1; + vm.set_ap(1); + vm.set_fp(1); let ids_data = ids_data!["num"]; let ap_tracking = ApTracking::new(); @@ -276,11 +271,7 @@ mod tests { divide_num_by_2(&mut vm, &ids_data, &ap_tracking).expect("Hint failed unexpectedly"); - let divided_num = vm - .segments - .memory - .get_integer(vm.run_context.get_ap()) - .unwrap(); + let divided_num = vm.get_integer(vm.get_ap()).unwrap(); assert_eq!(divided_num.into_owned(), expected_num_felt); } @@ -291,12 +282,7 @@ mod tests { set_ap_to_zero(&mut vm).expect("Hint failed unexpectedly"); - let ap_value = vm - .segments - .memory - .get_integer(vm.run_context.get_ap()) - .unwrap() - .into_owned(); + let ap_value = vm.get_integer(vm.get_ap()).unwrap().into_owned(); assert_eq!(ap_value, Felt252::from(0)); } @@ -305,8 +291,8 @@ mod tests { fn test_set_current_task(simple_bootloader_input: SimpleBootloaderInput) { // Set n_tasks to 1 let mut vm = vm!(); - vm.run_context.fp = 2; - vm.segments = segments![((1, 0), 1)]; + vm.set_fp(2); + define_segments!(vm, 2, [((1, 0), 1)]); let mut exec_scopes = ExecutionScopes::new(); exec_scopes.insert_value(vars::SIMPLE_BOOTLOADER_INPUT, simple_bootloader_input); diff --git a/src/lib.rs b/src/lib.rs index 964a021..0f5725f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,3 +12,200 @@ pub fn insert_bootloader_input( ) { exec_scopes.insert_value(BOOTLOADER_INPUT, bootloader_input); } + +#[macro_export] +macro_rules! vm { + () => { + VirtualMachine::new(false) // Default to false if no argument is provided + }; + ($trace_enabled:expr) => { + VirtualMachine::new($trace_enabled) + }; +} + +#[macro_export] +macro_rules! add_segments { + ($vm:expr, $n:expr) => { + for _ in 0..$n { + $vm.add_memory_segment(); + } + }; +} +#[macro_export] +macro_rules! ids_data { + ( $( $name: expr ),* ) => { + { + #[allow(clippy::useless_vec)] + let ids_names = vec![$( $name ),*]; + let references = $crate::references!(ids_names.len() as i32); + let mut ids_data = HashMap::::new(); + for (i, name) in ids_names.iter().enumerate() { + ids_data.insert(name.to_string(), references.get(&i).unwrap().clone()); + } + ids_data + } + }; +} +#[macro_export] +macro_rules! references { + ($num: expr) => {{ + let mut references = HashMap::< + usize, + cairo_vm::hint_processor::hint_processor_definition::HintReference, + >::new(); + for i in 0..$num { + references.insert( + i as usize, + cairo_vm::hint_processor::hint_processor_definition::HintReference::new_simple( + (i as i32), + ), + ); + } + references + }}; +} + +#[macro_export] +macro_rules! non_continuous_ids_data { + ( $( ($name: expr, $offset:expr) ),* $(,)? ) => { + { + let mut ids_data = cairo_vm::stdlib::collections::HashMap::::new(); + $( + ids_data.insert(cairo_vm::stdlib::string::String::from($name), HintReference::new_simple($offset)); + )* + ids_data + } + }; +} + +#[macro_export] +macro_rules! segments { + ($( (($si:expr, $off:expr), $val:tt) ),* $(,)? ) => { + { + let mut segments = cairo_vm::vm::vm_memory::memory_segments::MemorySegmentManager::new(); + segments.memory = $crate::memory!($( (($si, $off), $val) ),*); + segments + } + + }; +} + +#[macro_export] +macro_rules! memory { + ( $( (($si:expr, $off:expr), $val:tt) ),* ) => { + { + let mut memory = cairo_vm::vm::vm_memory::memory::Memory::new(); + $crate::memory_from_memory!(memory, ( $( (($si, $off), $val) ),* )); + memory + } + }; +} + +#[macro_export] +macro_rules! memory_from_memory { + ($mem: expr, ( $( (($si:expr, $off:expr), $val:tt) ),* )) => { + { + $( + $crate::memory_inner!($mem, ($si, $off), $val); + )* + } + }; +} + +#[macro_export] +macro_rules! insert_value_inner { + ($vm:expr, ($si:expr, $off:expr), ($sival:expr, $offval: expr)) => { + let (k, v) = ( + ($si, $off).into(), + &$crate::mayberelocatable!($sival, $offval), + ); + let mut res = $vm.insert_value(k, v); + while matches!( + res, + Err(cairo_vm::vm::errors::memory_errors::MemoryError::UnallocatedSegment(_)) + ) { + dbg!(&res); + if $si < 0 { + // $vm.temp_data.push(cairo_vm::stdlib::vec::Vec::new()) + } else { + // $vm.data.push(cairo_vm::stdlib::vec::Vec::new()); + } + res = $vm.insert_value(k, v); + } + }; + ($vm:expr, ($si:expr, $off:expr), $val:expr) => { + let (k, v) = (($si, $off).into(), &$crate::mayberelocatable!($val)); + let mut res = $vm.insert_value(k, v); + while matches!( + res, + Err(cairo_vm::vm::errors::memory_errors::MemoryError::UnallocatedSegment(_)) + ) { + dbg!(&res); + if $si < 0 { + // $mem.temp_data.push($crate::stdlib::vec::Vec::new()) + } else { + // $mem.data.push($crate::stdlib::vec::Vec::new()); + } + res = $vm.insert_value(k, v); + } + }; +} + +#[macro_export] +macro_rules! mayberelocatable { + ($val1 : expr, $val2 : expr) => { + cairo_vm::types::relocatable::MaybeRelocatable::from(($val1, $val2)) + }; + ($val1 : expr) => { + cairo_vm::types::relocatable::MaybeRelocatable::from(cairo_vm::Felt252::from($val1 as i128)) + }; +} + +#[macro_export] +macro_rules! define_segments { + ($vm:ident, $count:expr, [$( (($seg1:expr, $off1:expr), $val:tt) ),* $(,)?]) => { + for _ in 0..$count { + $vm.add_memory_segment(); + } + $( + $crate::insert_value_inner!($vm, ($seg1, $off1), $val); + )* + }; +} + + +macro_rules! run_hint { + ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr, $constants:expr) => {{ + let hint_data = HintProcessorData::new_default($hint_code.to_string(), $ids_data); + let mut hint_processor = $crate::MinimalBootloaderHintProcessor::new(); + hint_processor.execute_hint(&mut $vm, $exec_scopes, &any_box!(hint_data), $constants) + }}; + ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr) => {{ + let hint_data = HintProcessorData::new_default( + cairo_vm::stdlib::string::ToString::to_string($hint_code), + $ids_data, + ); + let mut hint_processor = $crate::MinimalBootloaderHintProcessor::new(); + hint_processor.execute_hint( + &mut $vm, + $exec_scopes, + &any_box!(hint_data), + &cairo_vm::stdlib::collections::HashMap::new(), + ) + }}; + ($vm:expr, $ids_data:expr, $hint_code:expr) => {{ + let hint_data = HintProcessorData::new_default( + crate::stdlib::string::ToString::to_string($hint_code), + $ids_data, + ); + let mut hint_processor = $crate::MinimalBootloaderHintProcessor::new(); + hint_processor.execute_hint( + &mut $vm, + exec_scopes_ref!(), + &any_box!(hint_data), + &crate::stdlib::collections::HashMap::new(), + ) + }}; +} +pub(crate) use run_hint; + From 418f224ba26400a869e5507c7d6576ee6aec90d1 Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Wed, 5 Jun 2024 14:19:24 +0300 Subject: [PATCH 11/28] fix: get most tests passing --- scripts/compile-bootloader.sh | 12 ----- src/hints/bootloader_hints.rs | 19 ++++--- src/hints/execute_task_hints.rs | 78 +++++++++++++++------------ src/hints/inner_select_builtins.rs | 2 +- src/hints/program_hash.rs | 12 ++--- src/hints/program_loader.rs | 12 +++-- src/hints/select_builtins.rs | 2 +- src/hints/simple_bootloader_hints.rs | 42 ++++++++------- src/hints/vars.rs | 2 +- src/lib.rs | 81 +++++++--------------------- 10 files changed, 113 insertions(+), 149 deletions(-) diff --git a/scripts/compile-bootloader.sh b/scripts/compile-bootloader.sh index cfc81a7..ada0b76 100644 --- a/scripts/compile-bootloader.sh +++ b/scripts/compile-bootloader.sh @@ -4,11 +4,7 @@ # to recompile the bootloader when changing the version of cairo-lang. SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) -<<<<<<< HEAD -CAIRO_VERSION="0.13.0" -======= CAIRO_VERSION="0.13.1" ->>>>>>> fb2312f0f9bda782d4d08e8c6bb0bdf77f904ed8 CAIRO_LANG_DIR=$(readlink -f "${SCRIPT_DIR}/../dependencies/cairo-lang") @@ -31,14 +27,6 @@ OUTPUT_DIR="$(readlink -f "${SCRIPT_DIR}/../resources")" mkdir -p "${OUTPUT_DIR}" COMPILED_BOOTLOADER="${OUTPUT_DIR}/bootloader-${CAIRO_VERSION}.json" -<<<<<<< HEAD -cairo-compile \ - "${CAIRO_LANG_DIR}/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" \ - --output "${COMPILED_BOOTLOADER}" \ - --cairo_path "${CAIRO_LANG_DIR}"/src \ - --proof_mode -======= cairo-compile "${CAIRO_LANG_DIR}/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" --output "${COMPILED_BOOTLOADER}" --cairo_path "${CAIRO_LANG_DIR}"/src ->>>>>>> fb2312f0f9bda782d4d08e8c6bb0bdf77f904ed8 echo "Compiled the bootloader to '${COMPILED_BOOTLOADER}'." \ No newline at end of file diff --git a/src/hints/bootloader_hints.rs b/src/hints/bootloader_hints.rs index 091ba2a..3687d97 100644 --- a/src/hints/bootloader_hints.rs +++ b/src/hints/bootloader_hints.rs @@ -434,14 +434,16 @@ mod tests { use num_traits::ToPrimitive; use crate::hints::codes::{ - BOOTLOADER_GUESS_PRE_IMAGE_OF_SUBTASKS_OUTPUT_HASH, BOOTLOADER_SAVE_OUTPUT_POINTER, BOOTLOADER_SAVE_PACKED_OUTPUTS, BOOTLOADER_SET_PACKED_OUTPUT_TO_SUBTASKS, EXECUTE_TASK_ASSERT_PROGRAM_ADDRESS + BOOTLOADER_GUESS_PRE_IMAGE_OF_SUBTASKS_OUTPUT_HASH, BOOTLOADER_SAVE_OUTPUT_POINTER, + BOOTLOADER_SAVE_PACKED_OUTPUTS, BOOTLOADER_SET_PACKED_OUTPUT_TO_SUBTASKS, + EXECUTE_TASK_ASSERT_PROGRAM_ADDRESS, }; use crate::hints::types::{BootloaderConfig, SimpleBootloaderInput}; - use crate::{add_segments, define_segments, ids_data, run_hint, segments, vm, MinimalBootloaderHintProcessor}; - use assert_matches::assert_matches; - use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::{ - BuiltinHintProcessor, HintProcessorData, + use crate::{ + add_segments, define_segments, ids_data, run_hint, vm, MinimalBootloaderHintProcessor, }; + use assert_matches::assert_matches; + use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData; use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_maybe_relocatable_from_var_name; use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; use cairo_vm::serde::deserialize_program::OffsetValue; @@ -564,7 +566,7 @@ mod tests { fn test_restore_bootloader_output() { let mut vm: VirtualMachine = vm!(); // The VM must have an existing output segment - let output_segment = vm.add_memory_segment(); + vm.add_memory_segment(); vm.builtin_runners = vec![OutputBuiltinRunner::new(true).into()]; let mut exec_scopes = ExecutionScopes::new(); @@ -686,8 +688,9 @@ mod tests { // Set n_subtasks to 2 vm.set_fp(1); define_segments!(vm, 2, [((1, 0), 2)]); - let ids_data = ids_data!["n_subtasks"]; - + // let ids_data = ids_data!["n_subtasks"]; + let ids_data = HashMap::from([("n_subtasks".to_string(), HintReference::new_simple(-1))]); + dbg!(&ids_data); let ap_tracking = ApTracking::default(); let mut exec_scopes = ExecutionScopes::new(); diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index 73321be..ecacc30 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -485,27 +485,24 @@ mod util { #[cfg(test)] mod tests { use std::path::Path; - use std::sync::Arc; use assert_matches::assert_matches; - use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::{ - BuiltinHintProcessor, HintProcessorData, - }; - use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::get_maybe_relocatable_from_var_name; + use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData; + + use cairo_vm::any_box; use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; - use cairo_vm::serde::deserialize_program::{OffsetValue, ReferenceManager}; + use cairo_vm::serde::deserialize_program::ReferenceManager; use cairo_vm::types::errors::math_errors::MathError; use cairo_vm::types::program::Program; use cairo_vm::types::relocatable::MaybeRelocatable; use cairo_vm::vm::runners::builtin_runner::BuiltinRunner; - use cairo_vm::vm::runners::cairo_pie::{BuiltinAdditionalData, OutputBuiltinAdditionalData, PublicMemoryPage}; - use cairo_vm::{any_box, relocatable, Felt252}; - use num_traits::ToPrimitive; + use cairo_vm::vm::runners::cairo_pie::{BuiltinAdditionalData, PublicMemoryPage}; + use rstest::{fixture, rstest}; use crate::hints::codes::EXECUTE_TASK_CALL_TASK; - use crate::hints::types::{BootloaderConfig, SimpleBootloaderInput}; - use crate::{add_segments, define_segments, ids_data, non_continuous_ids_data, run_hint, segments, vm}; + + use crate::{add_segments, define_segments, ids_data, non_continuous_ids_data, run_hint, vm}; use super::*; @@ -550,7 +547,8 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../cairo-programs/fibonacci.json").to_vec(); + include_bytes!("/home/geoff/Desktop/cairo-programs/cairo0/fibonacci/fibonacci.json") + .to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") @@ -558,15 +556,16 @@ mod tests { #[fixture] fn fibonacci_pie() -> CairoPie { - let pie_file = - Path::new("../cairo-programs/pie.zip"); + let pie_file = Path::new("/home/geoff/Desktop/cairo-vm/pie.zip"); CairoPie::read_zip_file(pie_file).expect("Failed to load the program PIE") } #[fixture] fn field_arithmetic_program() -> Program { - let program_content = - include_bytes!("../cairo-programs/fibonacci.json").to_vec(); + let program_content = include_bytes!( + "/home/geoff/Desktop/cairo-programs/cairo0/field-arithmetic/field_arithmetic.json" + ) + .to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") @@ -677,7 +676,8 @@ mod tests { identifiers, Default::default(), Default::default(), - ).unwrap(); + ) + .unwrap(); program } @@ -691,10 +691,13 @@ mod tests { // the Bootloader Cairo code. Our code only uses the first felt (`output` field in the // struct). Finally, we put the mocked output of `select_input_builtins` in the next // memory address and increase the AP register accordingly. - define_segments!(vm, 3, [((1, 0), (2, 0)), ((1, 1), (4, 0)), ((1, 9), (4, 42))]); + define_segments!( + vm, + 3, + [((1, 0), (2, 0)), ((1, 1), (4, 0)), ((1, 9), (4, 42))] + ); vm.set_ap(10); vm.set_fp(9); - add_segments!(vm, 3); let program_header_ptr = Relocatable::from((2, 0)); let ids_data = non_continuous_ids_data![ @@ -752,7 +755,7 @@ mod tests { (2, PublicMemoryPage { start: 7, size: 3 }), ]), attributes: HashMap::from([("gps_fact_topology".to_string(), tree_structure.clone())]), - base: 0 + base: 0, }; let mut output_builtin = OutputBuiltinRunner::new(true); output_builtin.set_state(program_output_data.clone()); @@ -769,9 +772,10 @@ mod tests { let mut exec_scopes = ExecutionScopes::new(); - let output_runner_data = OutputBuiltinAdditionalData { + let output_runner_data = OutputBuiltinState { pages: HashMap::new(), attributes: HashMap::new(), + base: 0, }; exec_scopes.insert_value(vars::OUTPUT_RUNNER_DATA, Some(output_runner_data.clone())); exec_scopes.insert_value(vars::TASK, task); @@ -793,7 +797,7 @@ mod tests { vm.get_output_builtin_mut().unwrap().get_additional_data(); assert!(matches!( output_builtin_additional_data, - BuiltinAdditionalData::Output(data) if data == output_runner_data, + BuiltinAdditionalData::Output(data) if data.pages == output_runner_data.pages && data.attributes == output_runner_data.attributes, )); } @@ -809,19 +813,23 @@ mod tests { // Initialize the used builtins to {range_check: 30, bitwise: 50} as these two // are used by the field arithmetic program. Note that the used builtins list // does not contain empty elements (i.e. offsets are 8 and 9 instead of 10 and 12). - define_segments!(vm, 2, [ - ((1, 0), (2, 1)), - ((1, 1), (2, 2)), - ((1, 2), (2, 3)), - ((1, 3), (2, 4)), - ((1, 4), (2, 5)), - ((1, 5), (2, 6)), - ((1, 6), (2, 7)), - ((1, 7), (2, 8)), - ((1, 8), (2, 30)), - ((1, 9), (2, 50)), - ((1, 24), (1, 8)), - ]); + define_segments!( + vm, + 2, + [ + ((1, 0), (2, 1)), + ((1, 1), (2, 2)), + ((1, 2), (2, 3)), + ((1, 3), (2, 4)), + ((1, 4), (2, 5)), + ((1, 5), (2, 6)), + ((1, 6), (2, 7)), + ((1, 7), (2, 8)), + ((1, 8), (2, 30)), + ((1, 9), (2, 50)), + ((1, 24), (1, 8)), + ] + ); vm.set_fp(25); add_segments!(vm, 1); diff --git a/src/hints/inner_select_builtins.rs b/src/hints/inner_select_builtins.rs index 50397bf..8b875b2 100644 --- a/src/hints/inner_select_builtins.rs +++ b/src/hints/inner_select_builtins.rs @@ -65,7 +65,7 @@ mod tests { use cairo_vm::Felt252; use rstest::rstest; - use crate::{add_segments, define_segments, ids_data, segments, vm}; + use crate::{add_segments, define_segments, ids_data, vm}; use super::*; diff --git a/src/hints/program_hash.rs b/src/hints/program_hash.rs index ac50c60..04e59cf 100644 --- a/src/hints/program_hash.rs +++ b/src/hints/program_hash.rs @@ -168,16 +168,16 @@ mod tests { #[rstest] // Expected hashes generated with `cairo-hash-program` #[case::fibonacci( - "../cairo_programs/fibonacci.json", - "0x43b17e9592f33142246af4c06cd2b574b460dd1f718d76b51341175a62b220f" + "/home/geoff/Desktop/cairo-programs/cairo0/fibonacci/fibonacci.json", + "0x6fc56a47599a5cc20bb3c6d4c5397f872bb6269f036e383f4c13986d4020952" )] #[case::field_arithmetic( - "../cairo_programs/field_arithmetic.json", - "0x1031772ca86e618b058101af9c9a3277bac90712b750bcea1cc69d6c7cad8a7" + "/home/geoff/Desktop/cairo-programs/cairo0/field-arithmetic/field_arithmetic.json", + "0xdc5a7432daec36bb707aa9f8cbcd60a2c5a4f5b16dbe7a4b6d96d5bfdd2a43" )] #[case::keccak_copy_inputs( - "../cairo_programs/keccak_copy_inputs.json", - "0x49484fdc8e7a85061f9f21b7e21fe276d8a88c8e96681101a2518809e686c6c" + "/home/geoff/Desktop/cairo-programs/cairo0/keccak-copy-inputs/keccak_copy_inputs.json", + "0x79e69539b9bbcc863519fb17f864c3439277cd851146f30d1ce0232fb358632" )] fn test_compute_program_hash_chain( #[case] program_path: PathBuf, diff --git a/src/hints/program_loader.rs b/src/hints/program_loader.rs index c53328b..6f13d50 100644 --- a/src/hints/program_loader.rs +++ b/src/hints/program_loader.rs @@ -165,7 +165,7 @@ impl<'vm> ProgramLoader<'vm> { #[cfg(test)] mod tests { - use std::any::Any; + use cairo_vm::types::builtin_name::BuiltinName; use cairo_vm::types::program::Program; @@ -173,11 +173,11 @@ mod tests { use cairo_vm::vm::runners::cairo_pie::StrippedProgram; use cairo_vm::vm::vm_memory::memory_segments::MemorySegmentManager; use cairo_vm::Felt252; - use num_traits::ToPrimitive; + use rstest::{fixture, rstest}; - use serde::Serialize; + - use crate::hints::types::BootloaderVersion; + use crate::{add_segments, hints::types::BootloaderVersion}; use super::*; @@ -242,7 +242,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../cairo-programs/fibonacci.json").to_vec(); + include_bytes!("/home/geoff/Desktop/test-cairo/fibonacci.json").to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") @@ -282,6 +282,7 @@ mod tests { let program = fibonacci.get_stripped_program().unwrap(); let mut vm = VirtualMachine::new(false); + add_segments!(vm, 2); let mut segments = MemorySegmentManager::new(); let base_address = segments.add(); @@ -318,6 +319,7 @@ mod tests { let program = fibonacci.get_stripped_program().unwrap(); let mut vm = VirtualMachine::new(false); + add_segments!(vm, 2); let mut segments = MemorySegmentManager::new(); let base_address = segments.add(); diff --git a/src/hints/select_builtins.rs b/src/hints/select_builtins.rs index 1f74203..bc97828 100644 --- a/src/hints/select_builtins.rs +++ b/src/hints/select_builtins.rs @@ -45,7 +45,7 @@ mod tests { use cairo_vm::vm::vm_core::VirtualMachine; use std::collections::HashMap; - use crate::{define_segments, ids_data, segments, vm}; + use crate::{define_segments, ids_data, vm}; use super::*; diff --git a/src/hints/simple_bootloader_hints.rs b/src/hints/simple_bootloader_hints.rs index acdee27..41fd1c9 100644 --- a/src/hints/simple_bootloader_hints.rs +++ b/src/hints/simple_bootloader_hints.rs @@ -134,30 +134,30 @@ mod tests { use std::collections::HashMap; use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{ - get_ptr_from_var_name, get_relocatable_from_var_name, insert_value_from_var_name, + get_ptr_from_var_name, + insert_value_from_var_name, }; + use cairo_vm::serde::deserialize_program::ApTracking; use cairo_vm::types::exec_scope::ExecutionScopes; use cairo_vm::types::program::Program; - use cairo_vm::types::relocatable::{MaybeRelocatable, Relocatable}; - use cairo_vm::vm::errors::hint_errors::HintError; - use cairo_vm::vm::errors::memory_errors::MemoryError; - use cairo_vm::vm::runners::builtin_runner::OutputBuiltinRunner; - use cairo_vm::vm::runners::cairo_pie::{ - CairoPie, OutputBuiltinAdditionalData, StrippedProgram, - }; + use cairo_vm::types::relocatable::{Relocatable}; + + + + use cairo_vm::vm::vm_core::VirtualMachine; - use cairo_vm::vm::vm_memory::memory::Memory; - use cairo_vm::{any_box, Felt252}; + + use cairo_vm::{Felt252}; use num_traits::ToPrimitive; use rstest::{fixture, rstest}; - use starknet_crypto::FieldElement; + - use crate::hints::fact_topologies::{get_task_fact_topology, FactTopology}; - use crate::hints::load_cairo_pie::load_cairo_pie; - use crate::hints::program_hash::compute_program_hash_chain; - use crate::hints::program_loader::ProgramLoader; - use crate::hints::types::{BootloaderVersion, Task, TaskSpec}; + use crate::hints::fact_topologies::{FactTopology}; + + + + use crate::hints::types::{Task, TaskSpec}; use crate::hints::vars; use crate::{add_segments, define_segments, ids_data, vm}; @@ -166,7 +166,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../cairo-programs/fibonacci.json").to_vec(); + include_bytes!("/home/geoff/Desktop/test-cairo/fibonacci.json").to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") @@ -260,9 +260,9 @@ mod tests { let expected_num_felt = Felt252::from(expected); let mut vm = vm!(); - add_segments!(vm, 2); vm.set_ap(1); vm.set_fp(1); + add_segments!(vm, 2); let ids_data = ids_data!["num"]; let ap_tracking = ApTracking::new(); @@ -298,8 +298,12 @@ mod tests { exec_scopes.insert_value(vars::SIMPLE_BOOTLOADER_INPUT, simple_bootloader_input); let ids_data = ids_data!["n_tasks", "task"]; + // let ids_data = HashMap::from([ + // ("n_tasks".to_string(), HintReference::new_simple(-2)), + // ("task".to_string(), HintReference::new_simple(-1)), + // ]); + dbg!(&ids_data); let ap_tracking = ApTracking::new(); - set_current_task(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) .expect("Hint failed unexpectedly"); diff --git a/src/hints/vars.rs b/src/hints/vars.rs index dd25c27..63b7dbc 100644 --- a/src/hints/vars.rs +++ b/src/hints/vars.rs @@ -2,7 +2,7 @@ pub const BOOTLOADER_INPUT: &str = "bootloader_input"; /// The bootloader program, as a Program object. -pub const BOOTLOADER_PROGRAM_IDENTIFIERS: &str = "bootloader_program"; +pub const BOOTLOADER_PROGRAM_IDENTIFIERS: &str = "bootloader_program_identifiers"; /// Saved state of the output builtin. pub const OUTPUT_BUILTIN_STATE: &str = "output_builtin_state"; diff --git a/src/lib.rs b/src/lib.rs index 0f5725f..6b8fa68 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -32,7 +32,7 @@ macro_rules! add_segments { }; } #[macro_export] -macro_rules! ids_data { +macro_rules! ids_data_old { ( $( $name: expr ),* ) => { { #[allow(clippy::useless_vec)] @@ -47,6 +47,20 @@ macro_rules! ids_data { }; } #[macro_export] +macro_rules! ids_data { + ( $( $key:expr ),* ) => {{ + let mut map = HashMap::::new(); + let ids_names = vec![$( $key ),*]; + let ids_len = ids_names.len() as i32; + let mut _value = -ids_len; + $( + map.insert($key.to_string(), cairo_vm::hint_processor::hint_processor_definition::HintReference::new_simple(_value)); + _value += 1; + )* + map + }}; +} +#[macro_export] macro_rules! references { ($num: expr) => {{ let mut references = HashMap::< @@ -78,39 +92,6 @@ macro_rules! non_continuous_ids_data { }; } -#[macro_export] -macro_rules! segments { - ($( (($si:expr, $off:expr), $val:tt) ),* $(,)? ) => { - { - let mut segments = cairo_vm::vm::vm_memory::memory_segments::MemorySegmentManager::new(); - segments.memory = $crate::memory!($( (($si, $off), $val) ),*); - segments - } - - }; -} - -#[macro_export] -macro_rules! memory { - ( $( (($si:expr, $off:expr), $val:tt) ),* ) => { - { - let mut memory = cairo_vm::vm::vm_memory::memory::Memory::new(); - $crate::memory_from_memory!(memory, ( $( (($si, $off), $val) ),* )); - memory - } - }; -} - -#[macro_export] -macro_rules! memory_from_memory { - ($mem: expr, ( $( (($si:expr, $off:expr), $val:tt) ),* )) => { - { - $( - $crate::memory_inner!($mem, ($si, $off), $val); - )* - } - }; -} #[macro_export] macro_rules! insert_value_inner { @@ -119,35 +100,13 @@ macro_rules! insert_value_inner { ($si, $off).into(), &$crate::mayberelocatable!($sival, $offval), ); - let mut res = $vm.insert_value(k, v); - while matches!( - res, - Err(cairo_vm::vm::errors::memory_errors::MemoryError::UnallocatedSegment(_)) - ) { - dbg!(&res); - if $si < 0 { - // $vm.temp_data.push(cairo_vm::stdlib::vec::Vec::new()) - } else { - // $vm.data.push(cairo_vm::stdlib::vec::Vec::new()); - } - res = $vm.insert_value(k, v); - } + $vm.insert_value(k, v).unwrap(); + }; ($vm:expr, ($si:expr, $off:expr), $val:expr) => { let (k, v) = (($si, $off).into(), &$crate::mayberelocatable!($val)); - let mut res = $vm.insert_value(k, v); - while matches!( - res, - Err(cairo_vm::vm::errors::memory_errors::MemoryError::UnallocatedSegment(_)) - ) { - dbg!(&res); - if $si < 0 { - // $mem.temp_data.push($crate::stdlib::vec::Vec::new()) - } else { - // $mem.data.push($crate::stdlib::vec::Vec::new()); - } - res = $vm.insert_value(k, v); - } + $vm.insert_value(k, v).unwrap(); + }; } @@ -174,6 +133,7 @@ macro_rules! define_segments { } +#[macro_export] macro_rules! run_hint { ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr, $constants:expr) => {{ let hint_data = HintProcessorData::new_default($hint_code.to_string(), $ids_data); @@ -207,5 +167,4 @@ macro_rules! run_hint { ) }}; } -pub(crate) use run_hint; From bfc698875cd2bfb86ba3d1bbd415410bb91ffe4f Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Wed, 5 Jun 2024 14:21:21 +0300 Subject: [PATCH 12/28] update: set the correct path of deps --- src/hints/execute_task_hints.rs | 6 +++--- src/hints/program_hash.rs | 6 +++--- src/hints/program_loader.rs | 2 +- src/hints/simple_bootloader_hints.rs | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index ecacc30..5030c5d 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -547,7 +547,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("/home/geoff/Desktop/cairo-programs/cairo0/fibonacci/fibonacci.json") + include_bytes!("../dependencies//cairo-programs/cairo0/fibonacci/fibonacci.json") .to_vec(); Program::from_bytes(&program_content, Some("main")) @@ -556,14 +556,14 @@ mod tests { #[fixture] fn fibonacci_pie() -> CairoPie { - let pie_file = Path::new("/home/geoff/Desktop/cairo-vm/pie.zip"); + let pie_file = Path::new("../dependencies//cairo-vm/pie.zip"); CairoPie::read_zip_file(pie_file).expect("Failed to load the program PIE") } #[fixture] fn field_arithmetic_program() -> Program { let program_content = include_bytes!( - "/home/geoff/Desktop/cairo-programs/cairo0/field-arithmetic/field_arithmetic.json" + "../dependencies//cairo-programs/cairo0/field-arithmetic/field_arithmetic.json" ) .to_vec(); diff --git a/src/hints/program_hash.rs b/src/hints/program_hash.rs index 04e59cf..1d83100 100644 --- a/src/hints/program_hash.rs +++ b/src/hints/program_hash.rs @@ -168,15 +168,15 @@ mod tests { #[rstest] // Expected hashes generated with `cairo-hash-program` #[case::fibonacci( - "/home/geoff/Desktop/cairo-programs/cairo0/fibonacci/fibonacci.json", + "../dependencies//cairo-programs/cairo0/fibonacci/fibonacci.json", "0x6fc56a47599a5cc20bb3c6d4c5397f872bb6269f036e383f4c13986d4020952" )] #[case::field_arithmetic( - "/home/geoff/Desktop/cairo-programs/cairo0/field-arithmetic/field_arithmetic.json", + "../dependencies//cairo-programs/cairo0/field-arithmetic/field_arithmetic.json", "0xdc5a7432daec36bb707aa9f8cbcd60a2c5a4f5b16dbe7a4b6d96d5bfdd2a43" )] #[case::keccak_copy_inputs( - "/home/geoff/Desktop/cairo-programs/cairo0/keccak-copy-inputs/keccak_copy_inputs.json", + "../dependencies//cairo-programs/cairo0/keccak-copy-inputs/keccak_copy_inputs.json", "0x79e69539b9bbcc863519fb17f864c3439277cd851146f30d1ce0232fb358632" )] fn test_compute_program_hash_chain( diff --git a/src/hints/program_loader.rs b/src/hints/program_loader.rs index 6f13d50..560685f 100644 --- a/src/hints/program_loader.rs +++ b/src/hints/program_loader.rs @@ -242,7 +242,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("/home/geoff/Desktop/test-cairo/fibonacci.json").to_vec(); + include_bytes!("../dependencies//test-cairo/fibonacci.json").to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") diff --git a/src/hints/simple_bootloader_hints.rs b/src/hints/simple_bootloader_hints.rs index 41fd1c9..4b81a44 100644 --- a/src/hints/simple_bootloader_hints.rs +++ b/src/hints/simple_bootloader_hints.rs @@ -168,7 +168,7 @@ mod tests { let program_content = include_bytes!("/home/geoff/Desktop/test-cairo/fibonacci.json").to_vec(); - Program::from_bytes(&program_content, Some("main")) + Program::from_bytes(../dependencies/ome("main")) .expect("Loading example program failed unexpectedly") } From cf518922941a36ff01851781c2723ce3cf88e967 Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Wed, 5 Jun 2024 14:26:21 +0300 Subject: [PATCH 13/28] update: set the correct path of deps --- src/hints/execute_task_hints.rs | 6 +++--- src/hints/program_hash.rs | 6 +++--- src/hints/program_loader.rs | 7 +++---- src/hints/simple_bootloader_hints.rs | 4 ++-- 4 files changed, 11 insertions(+), 12 deletions(-) diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index 5030c5d..514098c 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -547,7 +547,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../dependencies//cairo-programs/cairo0/fibonacci/fibonacci.json") + include_bytes!("../dependencies/cairo-programs/cairo0/fibonacci/fibonacci.json") .to_vec(); Program::from_bytes(&program_content, Some("main")) @@ -556,14 +556,14 @@ mod tests { #[fixture] fn fibonacci_pie() -> CairoPie { - let pie_file = Path::new("../dependencies//cairo-vm/pie.zip"); + let pie_file = Path::new("../dependencies/cairo-programs/cairo0/fibonacci/fibonacci.zip"); CairoPie::read_zip_file(pie_file).expect("Failed to load the program PIE") } #[fixture] fn field_arithmetic_program() -> Program { let program_content = include_bytes!( - "../dependencies//cairo-programs/cairo0/field-arithmetic/field_arithmetic.json" + "../dependencies/cairo-programs/cairo0/field-arithmetic/field_arithmetic.json" ) .to_vec(); diff --git a/src/hints/program_hash.rs b/src/hints/program_hash.rs index 1d83100..881943f 100644 --- a/src/hints/program_hash.rs +++ b/src/hints/program_hash.rs @@ -168,15 +168,15 @@ mod tests { #[rstest] // Expected hashes generated with `cairo-hash-program` #[case::fibonacci( - "../dependencies//cairo-programs/cairo0/fibonacci/fibonacci.json", + "../dependencies/cairo-programs/cairo0/fibonacci/fibonacci.json", "0x6fc56a47599a5cc20bb3c6d4c5397f872bb6269f036e383f4c13986d4020952" )] #[case::field_arithmetic( - "../dependencies//cairo-programs/cairo0/field-arithmetic/field_arithmetic.json", + "../dependencies/cairo-programs/cairo0/field-arithmetic/field_arithmetic.json", "0xdc5a7432daec36bb707aa9f8cbcd60a2c5a4f5b16dbe7a4b6d96d5bfdd2a43" )] #[case::keccak_copy_inputs( - "../dependencies//cairo-programs/cairo0/keccak-copy-inputs/keccak_copy_inputs.json", + "../dependencies/cairo-programs/cairo0/keccak-copy-inputs/keccak_copy_inputs.json", "0x79e69539b9bbcc863519fb17f864c3439277cd851146f30d1ce0232fb358632" )] fn test_compute_program_hash_chain( diff --git a/src/hints/program_loader.rs b/src/hints/program_loader.rs index 560685f..bcd593c 100644 --- a/src/hints/program_loader.rs +++ b/src/hints/program_loader.rs @@ -165,7 +165,6 @@ impl<'vm> ProgramLoader<'vm> { #[cfg(test)] mod tests { - use cairo_vm::types::builtin_name::BuiltinName; use cairo_vm::types::program::Program; @@ -173,9 +172,8 @@ mod tests { use cairo_vm::vm::runners::cairo_pie::StrippedProgram; use cairo_vm::vm::vm_memory::memory_segments::MemorySegmentManager; use cairo_vm::Felt252; - + use rstest::{fixture, rstest}; - use crate::{add_segments, hints::types::BootloaderVersion}; @@ -242,7 +240,8 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../dependencies//test-cairo/fibonacci.json").to_vec(); + include_bytes!("../dependencies/cairo-programs/cairo0/fibonacci/fibonacci.json") + .to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") diff --git a/src/hints/simple_bootloader_hints.rs b/src/hints/simple_bootloader_hints.rs index 4b81a44..a0f2026 100644 --- a/src/hints/simple_bootloader_hints.rs +++ b/src/hints/simple_bootloader_hints.rs @@ -166,9 +166,9 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("/home/geoff/Desktop/test-cairo/fibonacci.json").to_vec(); + include_bytes!("../dependencies/cairo-programs/cairo0/fibonacci/fibonacci.json").to_vec(); - Program::from_bytes(../dependencies/ome("main")) + Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") } From 62347335d6bccfab7086829367399b0aba82d8dd Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Wed, 5 Jun 2024 16:02:40 +0300 Subject: [PATCH 14/28] add: test-programs submodule --- .gitmodules | 3 +++ test-prgrams | 1 + 2 files changed, 4 insertions(+) create mode 160000 test-prgrams diff --git a/.gitmodules b/.gitmodules index c0ee744..7a38ea9 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,6 @@ [submodule "dependencies/cairo-lang"] path = dependencies/cairo-lang url = https://github.com/starkware-libs/cairo-lang +[submodule "test-prgrams"] + path = test-prgrams + url = https://github.com/Moonsong-Labs/cairo-programs diff --git a/test-prgrams b/test-prgrams new file mode 160000 index 0000000..b3a7981 --- /dev/null +++ b/test-prgrams @@ -0,0 +1 @@ +Subproject commit b3a798100623919afefb3a2fa5a6bfe45f1ca9d7 From daacd877b402f14e4da5d6e37b04eb34082db730 Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Wed, 5 Jun 2024 16:11:09 +0300 Subject: [PATCH 15/28] update: the missing dependencies --- .gitmodules | 4 ++-- src/hints/execute_task_hints.rs | 6 +++--- src/hints/program_hash.rs | 6 +++--- src/hints/program_loader.rs | 2 +- src/hints/simple_bootloader_hints.rs | 2 +- test-prgrams => test-programs | 0 6 files changed, 10 insertions(+), 10 deletions(-) rename test-prgrams => test-programs (100%) diff --git a/.gitmodules b/.gitmodules index 7a38ea9..079f700 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,6 +1,6 @@ [submodule "dependencies/cairo-lang"] path = dependencies/cairo-lang url = https://github.com/starkware-libs/cairo-lang -[submodule "test-prgrams"] - path = test-prgrams +[submodule "test-programs"] + path = test-programs url = https://github.com/Moonsong-Labs/cairo-programs diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index 514098c..2998e1a 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -547,7 +547,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../dependencies/cairo-programs/cairo0/fibonacci/fibonacci.json") + include_bytes!("../../test-programs/cairo0/fibonacci/fibonacci.json") .to_vec(); Program::from_bytes(&program_content, Some("main")) @@ -556,14 +556,14 @@ mod tests { #[fixture] fn fibonacci_pie() -> CairoPie { - let pie_file = Path::new("../dependencies/cairo-programs/cairo0/fibonacci/fibonacci.zip"); + let pie_file = Path::new("../../test-programs/bootloader/pies/fibonacci/cairo_pie.zip"); CairoPie::read_zip_file(pie_file).expect("Failed to load the program PIE") } #[fixture] fn field_arithmetic_program() -> Program { let program_content = include_bytes!( - "../dependencies/cairo-programs/cairo0/field-arithmetic/field_arithmetic.json" + "../../test-programs/cairo0/field-arithmetic/field_arithmetic.json" ) .to_vec(); diff --git a/src/hints/program_hash.rs b/src/hints/program_hash.rs index 881943f..d2e7a85 100644 --- a/src/hints/program_hash.rs +++ b/src/hints/program_hash.rs @@ -168,15 +168,15 @@ mod tests { #[rstest] // Expected hashes generated with `cairo-hash-program` #[case::fibonacci( - "../dependencies/cairo-programs/cairo0/fibonacci/fibonacci.json", + "./test-programs/cairo0/fibonacci/fibonacci.json", "0x6fc56a47599a5cc20bb3c6d4c5397f872bb6269f036e383f4c13986d4020952" )] #[case::field_arithmetic( - "../dependencies/cairo-programs/cairo0/field-arithmetic/field_arithmetic.json", + "./test-programs/cairo0/field-arithmetic/field_arithmetic.json", "0xdc5a7432daec36bb707aa9f8cbcd60a2c5a4f5b16dbe7a4b6d96d5bfdd2a43" )] #[case::keccak_copy_inputs( - "../dependencies/cairo-programs/cairo0/keccak-copy-inputs/keccak_copy_inputs.json", + "./test-programs/cairo0/keccak-copy-inputs/keccak_copy_inputs.json", "0x79e69539b9bbcc863519fb17f864c3439277cd851146f30d1ce0232fb358632" )] fn test_compute_program_hash_chain( diff --git a/src/hints/program_loader.rs b/src/hints/program_loader.rs index bcd593c..8f65281 100644 --- a/src/hints/program_loader.rs +++ b/src/hints/program_loader.rs @@ -240,7 +240,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../dependencies/cairo-programs/cairo0/fibonacci/fibonacci.json") + include_bytes!("../../test-programs/cairo0/fibonacci/fibonacci.json") .to_vec(); Program::from_bytes(&program_content, Some("main")) diff --git a/src/hints/simple_bootloader_hints.rs b/src/hints/simple_bootloader_hints.rs index a0f2026..5ba3233 100644 --- a/src/hints/simple_bootloader_hints.rs +++ b/src/hints/simple_bootloader_hints.rs @@ -166,7 +166,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../dependencies/cairo-programs/cairo0/fibonacci/fibonacci.json").to_vec(); + include_bytes!("../../test-programs/cairo0/fibonacci/fibonacci.json").to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") diff --git a/test-prgrams b/test-programs similarity index 100% rename from test-prgrams rename to test-programs From a76fec3384e01fdb4ab391af5a66f67ebe89476b Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Wed, 5 Jun 2024 16:12:23 +0300 Subject: [PATCH 16/28] lint: clippy --- src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index 6b8fa68..c2dd30b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -155,7 +155,7 @@ macro_rules! run_hint { }}; ($vm:expr, $ids_data:expr, $hint_code:expr) => {{ let hint_data = HintProcessorData::new_default( - crate::stdlib::string::ToString::to_string($hint_code), + $crate::stdlib::string::ToString::to_string($hint_code), $ids_data, ); let mut hint_processor = $crate::MinimalBootloaderHintProcessor::new(); From 3597f30fd40331517bc61bbd1ab5244a58d999ac Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Wed, 5 Jun 2024 16:14:55 +0300 Subject: [PATCH 17/28] lint: rustfmt --- src/hints/execute_task_hints.rs | 10 ++++------ src/hints/program_loader.rs | 3 +-- src/hints/simple_bootloader_hints.rs | 23 ++++++++--------------- src/lib.rs | 5 ----- 4 files changed, 13 insertions(+), 28 deletions(-) diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index 2998e1a..66b3300 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -547,8 +547,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../../test-programs/cairo0/fibonacci/fibonacci.json") - .to_vec(); + include_bytes!("../../test-programs/cairo0/fibonacci/fibonacci.json").to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") @@ -562,10 +561,9 @@ mod tests { #[fixture] fn field_arithmetic_program() -> Program { - let program_content = include_bytes!( - "../../test-programs/cairo0/field-arithmetic/field_arithmetic.json" - ) - .to_vec(); + let program_content = + include_bytes!("../../test-programs/cairo0/field-arithmetic/field_arithmetic.json") + .to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") diff --git a/src/hints/program_loader.rs b/src/hints/program_loader.rs index 8f65281..3664a10 100644 --- a/src/hints/program_loader.rs +++ b/src/hints/program_loader.rs @@ -240,8 +240,7 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../../test-programs/cairo0/fibonacci/fibonacci.json") - .to_vec(); + include_bytes!("../../test-programs/cairo0/fibonacci/fibonacci.json").to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") diff --git a/src/hints/simple_bootloader_hints.rs b/src/hints/simple_bootloader_hints.rs index 5ba3233..65140ac 100644 --- a/src/hints/simple_bootloader_hints.rs +++ b/src/hints/simple_bootloader_hints.rs @@ -134,29 +134,22 @@ mod tests { use std::collections::HashMap; use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{ - get_ptr_from_var_name, - insert_value_from_var_name, + get_ptr_from_var_name, insert_value_from_var_name, }; - + use cairo_vm::serde::deserialize_program::ApTracking; use cairo_vm::types::exec_scope::ExecutionScopes; use cairo_vm::types::program::Program; - use cairo_vm::types::relocatable::{Relocatable}; - - - - + use cairo_vm::types::relocatable::Relocatable; + use cairo_vm::vm::vm_core::VirtualMachine; - - use cairo_vm::{Felt252}; + + use cairo_vm::Felt252; use num_traits::ToPrimitive; use rstest::{fixture, rstest}; - - use crate::hints::fact_topologies::{FactTopology}; - - - + use crate::hints::fact_topologies::FactTopology; + use crate::hints::types::{Task, TaskSpec}; use crate::hints::vars; use crate::{add_segments, define_segments, ids_data, vm}; diff --git a/src/lib.rs b/src/lib.rs index c2dd30b..045ae53 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -92,7 +92,6 @@ macro_rules! non_continuous_ids_data { }; } - #[macro_export] macro_rules! insert_value_inner { ($vm:expr, ($si:expr, $off:expr), ($sival:expr, $offval: expr)) => { @@ -101,12 +100,10 @@ macro_rules! insert_value_inner { &$crate::mayberelocatable!($sival, $offval), ); $vm.insert_value(k, v).unwrap(); - }; ($vm:expr, ($si:expr, $off:expr), $val:expr) => { let (k, v) = (($si, $off).into(), &$crate::mayberelocatable!($val)); $vm.insert_value(k, v).unwrap(); - }; } @@ -132,7 +129,6 @@ macro_rules! define_segments { }; } - #[macro_export] macro_rules! run_hint { ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr, $constants:expr) => {{ @@ -167,4 +163,3 @@ macro_rules! run_hint { ) }}; } - From a03588e6549512f8c85ff0b75c9d771747d88284 Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Wed, 5 Jun 2024 16:17:02 +0300 Subject: [PATCH 18/28] lint: clippy --- src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib.rs b/src/lib.rs index 045ae53..9cd4457 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -159,7 +159,7 @@ macro_rules! run_hint { &mut $vm, exec_scopes_ref!(), &any_box!(hint_data), - &crate::stdlib::collections::HashMap::new(), + &$crate::stdlib::collections::HashMap::new(), ) }}; } From 1481c3c99eb9770be70fc6ff934bfa669f131dbe Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Wed, 5 Jun 2024 15:27:33 +0200 Subject: [PATCH 19/28] move test-programs + fix PIE loading --- .gitmodules | 2 +- test-programs => dependencies/test-programs | 0 src/hints/execute_task_hints.rs | 18 ++++++++++-------- src/hints/program_loader.rs | 6 ++---- src/hints/simple_bootloader_hints.rs | 3 ++- 5 files changed, 15 insertions(+), 14 deletions(-) rename test-programs => dependencies/test-programs (100%) diff --git a/.gitmodules b/.gitmodules index 079f700..7724ea1 100644 --- a/.gitmodules +++ b/.gitmodules @@ -2,5 +2,5 @@ path = dependencies/cairo-lang url = https://github.com/starkware-libs/cairo-lang [submodule "test-programs"] - path = test-programs + path = dependencies/test-programs url = https://github.com/Moonsong-Labs/cairo-programs diff --git a/test-programs b/dependencies/test-programs similarity index 100% rename from test-programs rename to dependencies/test-programs diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index 66b3300..d8aeaac 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -484,8 +484,6 @@ mod util { #[cfg(test)] mod tests { - use std::path::Path; - use assert_matches::assert_matches; use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData; @@ -547,7 +545,8 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../../test-programs/cairo0/fibonacci/fibonacci.json").to_vec(); + include_bytes!("../../dependencies/test-programs/cairo0/fibonacci/fibonacci.json") + .to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") @@ -555,15 +554,18 @@ mod tests { #[fixture] fn fibonacci_pie() -> CairoPie { - let pie_file = Path::new("../../test-programs/bootloader/pies/fibonacci/cairo_pie.zip"); - CairoPie::read_zip_file(pie_file).expect("Failed to load the program PIE") + let pie_content = include_bytes!( + "../../dependencies/test-programs/bootloader/pies/fibonacci/cairo_pie.zip" + ); + CairoPie::from_bytes(pie_content).expect("Failed to load the program PIE") } #[fixture] fn field_arithmetic_program() -> Program { - let program_content = - include_bytes!("../../test-programs/cairo0/field-arithmetic/field_arithmetic.json") - .to_vec(); + let program_content = include_bytes!( + "../../dependencies/test-programs/cairo0/field-arithmetic/field_arithmetic.json" + ) + .to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") diff --git a/src/hints/program_loader.rs b/src/hints/program_loader.rs index 3664a10..bbdadd7 100644 --- a/src/hints/program_loader.rs +++ b/src/hints/program_loader.rs @@ -165,14 +165,12 @@ impl<'vm> ProgramLoader<'vm> { #[cfg(test)] mod tests { - use cairo_vm::types::builtin_name::BuiltinName; use cairo_vm::types::program::Program; use cairo_vm::types::relocatable::Relocatable; use cairo_vm::vm::runners::cairo_pie::StrippedProgram; use cairo_vm::vm::vm_memory::memory_segments::MemorySegmentManager; use cairo_vm::Felt252; - use rstest::{fixture, rstest}; use crate::{add_segments, hints::types::BootloaderVersion}; @@ -240,9 +238,9 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../../test-programs/cairo0/fibonacci/fibonacci.json").to_vec(); + include_bytes!("../../dependencies/test-programs/cairo0/fibonacci/fibonacci.json"); - Program::from_bytes(&program_content, Some("main")) + Program::from_bytes(program_content, Some("main")) .expect("Loading example program failed unexpectedly") } diff --git a/src/hints/simple_bootloader_hints.rs b/src/hints/simple_bootloader_hints.rs index 65140ac..985a22f 100644 --- a/src/hints/simple_bootloader_hints.rs +++ b/src/hints/simple_bootloader_hints.rs @@ -159,7 +159,8 @@ mod tests { #[fixture] fn fibonacci() -> Program { let program_content = - include_bytes!("../../test-programs/cairo0/fibonacci/fibonacci.json").to_vec(); + include_bytes!("../../dependencies/test-programs/cairo0/fibonacci/fibonacci.json") + .to_vec(); Program::from_bytes(&program_content, Some("main")) .expect("Loading example program failed unexpectedly") From ef1e51f0e01c80e7ac1d903ae340588619270cc0 Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Wed, 5 Jun 2024 15:39:46 +0200 Subject: [PATCH 20/28] fix bootloader identifiers --- src/hints/bootloader_hints.rs | 2 ++ src/hints/execute_task_hints.rs | 35 ++++++++++++--------------------- src/hints/fact_topologies.rs | 2 ++ src/hints/program_hash.rs | 9 +++++---- 4 files changed, 22 insertions(+), 26 deletions(-) diff --git a/src/hints/bootloader_hints.rs b/src/hints/bootloader_hints.rs index 3687d97..2b2db2e 100644 --- a/src/hints/bootloader_hints.rs +++ b/src/hints/bootloader_hints.rs @@ -22,6 +22,7 @@ use crate::hints::types::{BootloaderInput, CompositePackedOutput, PackedOutput}; use crate::hints::vars; /// Implements +/// ```no-run /// %{ /// from starkware.cairo.bootloaders.bootloader.objects import BootloaderInput /// bootloader_input = BootloaderInput.Schema().load(program_input) @@ -33,6 +34,7 @@ use crate::hints::vars; /// output_builtin_state = output_builtin.get_state() /// output_builtin.new_state(base=ids.simple_bootloader_output_start) /// %} +/// ``` pub fn prepare_simple_bootloader_output_segment( vm: &mut VirtualMachine, exec_scopes: &mut ExecutionScopes, diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index d8aeaac..e1e2ec7 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -314,9 +314,13 @@ pub fn write_return_builtins_hint( Ok(()) } -fn get_bootloader_program(exec_scopes: &ExecutionScopes) -> Result<&ProgramIdentifiers, HintError> { - if let Some(boxed_program) = exec_scopes.data[0].get(vars::BOOTLOADER_PROGRAM_IDENTIFIERS) { - if let Some(program) = boxed_program.downcast_ref::() { +fn get_bootloader_identifiers( + exec_scopes: &ExecutionScopes, +) -> Result<&ProgramIdentifiers, HintError> { + if let Some(bootloader_identifiers) = + exec_scopes.data[0].get(vars::BOOTLOADER_PROGRAM_IDENTIFIERS) + { + if let Some(program) = bootloader_identifiers.downcast_ref::() { return Ok(program); } } @@ -413,7 +417,7 @@ pub fn call_task( let program_address: Relocatable = exec_scopes.get("program_address")?; // ret_pc = ids.ret_pc_label.instruction_offset_ - ids.call_task.instruction_offset_ + pc - let bootloader_identifiers = get_bootloader_program(exec_scopes)?; + let bootloader_identifiers = get_bootloader_identifiers(exec_scopes)?; let ret_pc_label = get_identifier(bootloader_identifiers, "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ret_pc_label")?; let call_task = get_identifier( bootloader_identifiers, @@ -489,7 +493,6 @@ mod tests { use cairo_vm::any_box; use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; - use cairo_vm::serde::deserialize_program::ReferenceManager; use cairo_vm::types::errors::math_errors::MathError; use cairo_vm::types::program::Program; use cairo_vm::types::relocatable::MaybeRelocatable; @@ -649,7 +652,7 @@ mod tests { /// * a `HasIdentifiers` trait cannot be used as exec_scopes requires to cast to `Box`, /// making casting back to the trait impossible. /// * using an enum requires defining test-only variants. - fn mock_program_with_identifiers(symbols: HashMap) -> Program { + fn mock_program_identifiers(symbols: HashMap) -> ProgramIdentifiers { let identifiers = symbols .into_iter() .map(|(name, pc)| { @@ -667,19 +670,7 @@ mod tests { }) .collect(); - let program = Program::new( - vec![], - Default::default(), - Default::default(), - Default::default(), - ReferenceManager::default(), - identifiers, - Default::default(), - Default::default(), - ) - .unwrap(); - - program + identifiers } #[rstest] @@ -693,7 +684,7 @@ mod tests { // memory address and increase the AP register accordingly. define_segments!( vm, - 3, + 4, [((1, 0), (2, 0)), ((1, 1), (4, 0)), ((1, 9), (4, 42))] ); vm.set_ap(10); @@ -721,9 +712,9 @@ mod tests { ("starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.call_task".to_string(), 8usize) ] ); - let bootloader_program = mock_program_with_identifiers(bootloader_identifiers); + let program_identifiers = mock_program_identifiers(bootloader_identifiers); exec_scopes.insert_value(vars::PROGRAM_DATA_BASE, program_header_ptr.clone()); - exec_scopes.insert_value(vars::BOOTLOADER_PROGRAM_IDENTIFIERS, bootloader_program); + exec_scopes.insert_value(vars::BOOTLOADER_PROGRAM_IDENTIFIERS, program_identifiers); // Load the program in memory load_program_hint(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) diff --git a/src/hints/fact_topologies.rs b/src/hints/fact_topologies.rs index d3b851a..1ad70ff 100644 --- a/src/hints/fact_topologies.rs +++ b/src/hints/fact_topologies.rs @@ -154,6 +154,7 @@ pub fn compute_fact_topologies<'a>( /// * `output_start`: Start of the output range for this fact topology. /// /// Reimplements the following Python code: +/// ```no-run /// offset = 0 /// for i, page_size in enumerate(fact_topology.page_sizes): /// output_builtin.add_page( @@ -162,6 +163,7 @@ pub fn compute_fact_topologies<'a>( /// offset += page_size /// /// return len(fact_topology.page_sizes) +/// ``` fn add_consecutive_output_pages( fact_topology: &FactTopology, output_builtin: &mut OutputBuiltinRunner, diff --git a/src/hints/program_hash.rs b/src/hints/program_hash.rs index d2e7a85..d8a01ec 100644 --- a/src/hints/program_hash.rs +++ b/src/hints/program_hash.rs @@ -84,10 +84,10 @@ fn maybe_relocatable_to_field_element( felt_to_field_element(felt) } -#[allow(dead_code)] // TODO: remove /// Computes the Pedersen hash of a program. /// /// Reimplements this Python function: +/// ```no-run /// def compute_program_hash_chain(program: ProgramBase, bootloader_version=0): /// builtin_list = [from_bytes(builtin.encode("ascii")) for builtin in program.builtins] /// # The program header below is missing the data length, which is later added to the data_chain. @@ -95,6 +95,7 @@ fn maybe_relocatable_to_field_element( /// data_chain = program_header + program.data /// /// return compute_hash_chain([len(data_chain)] + data_chain) +/// ``` pub fn compute_program_hash_chain( program: &StrippedProgram, bootloader_version: usize, @@ -168,15 +169,15 @@ mod tests { #[rstest] // Expected hashes generated with `cairo-hash-program` #[case::fibonacci( - "./test-programs/cairo0/fibonacci/fibonacci.json", + "./dependencies/test-programs/cairo0/fibonacci/fibonacci.json", "0x6fc56a47599a5cc20bb3c6d4c5397f872bb6269f036e383f4c13986d4020952" )] #[case::field_arithmetic( - "./test-programs/cairo0/field-arithmetic/field_arithmetic.json", + "./dependencies/test-programs/cairo0/field-arithmetic/field_arithmetic.json", "0xdc5a7432daec36bb707aa9f8cbcd60a2c5a4f5b16dbe7a4b6d96d5bfdd2a43" )] #[case::keccak_copy_inputs( - "./test-programs/cairo0/keccak-copy-inputs/keccak_copy_inputs.json", + "./dependencies/test-programs/cairo0/keccak-copy-inputs/keccak_copy_inputs.json", "0x79e69539b9bbcc863519fb17f864c3439277cd851146f30d1ce0232fb358632" )] fn test_compute_program_hash_chain( From de16faf081ddc52500e2d150841935fe09421ee2 Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Wed, 5 Jun 2024 15:42:10 +0200 Subject: [PATCH 21/28] reactivate ci --- .github/workflows/check.yml | 30 ++++++++++++++---------------- 1 file changed, 14 insertions(+), 16 deletions(-) diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index 74fc658..50e6baf 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -24,28 +24,26 @@ jobs: - uses: Swatinem/rust-cache@v2 - run: cargo clippy --all -- -D warnings - # tests: - # runs-on: ubuntu-latest - # steps: - # - uses: actions/checkout@v4 - # with: - # submodules: "true" - # - run: rustup show - # - uses: Swatinem/rust-cache@v2 - # - uses: actions/setup-python@v4 - # with: - # python-version: '3.11' - # - run: | - # bash ./scripts/reset-tests.sh - # RUSTFLAGS="-D warnings" cargo test + tests: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + submodules: "true" + - run: rustup show + - uses: Swatinem/rust-cache@v2 + - name: Run Rust tests + run: | + RUSTFLAGS="-D warnings" cargo test udeps: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - run: rustup show + - run: rustup toolchain install nightly --profile minimal - uses: Swatinem/rust-cache@v2 with: cache-on-failure: true - run: cargo install cargo-udeps --locked - - run: cargo udeps --all-targets + - name: Run udeps + run: cargo +nightly udeps --all-targets From 9dadc096fd8817eab9d0e86e0d883ef04af8d956 Mon Sep 17 00:00:00 2001 From: Olivier Desenfans Date: Wed, 5 Jun 2024 15:44:23 +0200 Subject: [PATCH 22/28] submodules --- .github/workflows/check.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/check.yml b/.github/workflows/check.yml index 50e6baf..d1ffe66 100644 --- a/.github/workflows/check.yml +++ b/.github/workflows/check.yml @@ -11,6 +11,8 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 + with: + submodules: "true" - run: rustup show - run: rustup component add rustfmt - uses: Swatinem/rust-cache@v2 @@ -20,6 +22,8 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 + with: + submodules: "true" - run: rustup show - uses: Swatinem/rust-cache@v2 - run: cargo clippy --all -- -D warnings @@ -40,6 +44,8 @@ jobs: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 + with: + submodules: "true" - run: rustup toolchain install nightly --profile minimal - uses: Swatinem/rust-cache@v2 with: From 3f2c0579421e7c820de4f14ed638160dda3ea4d0 Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Wed, 5 Jun 2024 16:53:40 +0300 Subject: [PATCH 23/28] remove: dbg points --- src/hints/bootloader_hints.rs | 1 - src/hints/inner_select_builtins.rs | 1 - src/hints/simple_bootloader_hints.rs | 5 ----- 3 files changed, 7 deletions(-) diff --git a/src/hints/bootloader_hints.rs b/src/hints/bootloader_hints.rs index 2b2db2e..daed1f1 100644 --- a/src/hints/bootloader_hints.rs +++ b/src/hints/bootloader_hints.rs @@ -692,7 +692,6 @@ mod tests { define_segments!(vm, 2, [((1, 0), 2)]); // let ids_data = ids_data!["n_subtasks"]; let ids_data = HashMap::from([("n_subtasks".to_string(), HintReference::new_simple(-1))]); - dbg!(&ids_data); let ap_tracking = ApTracking::default(); let mut exec_scopes = ExecutionScopes::new(); diff --git a/src/hints/inner_select_builtins.rs b/src/hints/inner_select_builtins.rs index 8b875b2..d1fc033 100644 --- a/src/hints/inner_select_builtins.rs +++ b/src/hints/inner_select_builtins.rs @@ -97,7 +97,6 @@ mod tests { vm.set_fp(3); add_segments!(vm, 2); let ids_data = ids_data!["selected_encodings", "all_encodings", "select_builtin"]; - // dbg!(&ids_data); let ap_tracking = ApTracking::new(); let mut exec_scopes = ExecutionScopes::new(); diff --git a/src/hints/simple_bootloader_hints.rs b/src/hints/simple_bootloader_hints.rs index 985a22f..3c67f94 100644 --- a/src/hints/simple_bootloader_hints.rs +++ b/src/hints/simple_bootloader_hints.rs @@ -292,11 +292,6 @@ mod tests { exec_scopes.insert_value(vars::SIMPLE_BOOTLOADER_INPUT, simple_bootloader_input); let ids_data = ids_data!["n_tasks", "task"]; - // let ids_data = HashMap::from([ - // ("n_tasks".to_string(), HintReference::new_simple(-2)), - // ("task".to_string(), HintReference::new_simple(-1)), - // ]); - dbg!(&ids_data); let ap_tracking = ApTracking::new(); set_current_task(&mut vm, &mut exec_scopes, &ids_data, &ap_tracking) .expect("Hint failed unexpectedly"); From 81deb991e449e74e7823e73a6a99a0579093f617 Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Thu, 6 Jun 2024 12:48:52 +0300 Subject: [PATCH 24/28] fix: based on review --- Cargo.toml | 4 +- resources/bootloader-0.13.1.json | 35810 ----------------------------- scripts/compile-bootloader.sh | 8 +- src/hints/bootloader_hints.rs | 19 +- src/hints/execute_task_hints.rs | 6 +- src/hints/hint_processor.rs | 124 - src/lib.rs | 156 +- src/macros.rs | 134 + 8 files changed, 160 insertions(+), 36101 deletions(-) delete mode 100644 resources/bootloader-0.13.1.json delete mode 100644 src/hints/hint_processor.rs create mode 100644 src/macros.rs diff --git a/Cargo.toml b/Cargo.toml index 37c32d6..ae4d641 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -6,9 +6,7 @@ edition = "2021" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] -cairo-vm = { git = "https://github.com/lambdaclass/cairo-vm", rev = "05352b1c67859a4d8cd128575c1e68ca7e300341", features = [ - "extensive_hints", -] } +cairo-vm = { git = "https://github.com/lambdaclass/cairo-vm", rev = "05352b1c67859a4d8cd128575c1e68ca7e300341", features = ["extensive_hints"] } num-traits = "0.2.19" serde = { version = "1.0.202", features = ["derive"] } serde_json = "1.0.117" diff --git a/resources/bootloader-0.13.1.json b/resources/bootloader-0.13.1.json deleted file mode 100644 index 517ab31..0000000 --- a/resources/bootloader-0.13.1.json +++ /dev/null @@ -1,35810 +0,0 @@ -{ - "attributes": [], - "builtins": [ - "output", - "pedersen", - "range_check", - "ecdsa", - "bitwise", - "ec_op", - "keccak", - "poseidon", - "range_check96" - ], - "compiler_version": "0.13.0", - "data": [ - "0x208b7fff7fff7ffe", - "0x1104800180018000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x482480017ffe8000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffff", - "0x208b7fff7fff7ffe", - "0x20780017fff7ffd", - "0x4", - "0x480a7ffb7fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x3", - "0x404b800080008000", - "0x400380007ff98001", - "0x400380007ffa8002", - "0x20780017fff8000", - "0x4", - "0x10780017fff7fff", - "0x4", - "0x400380007ffb8001", - "0x400380007ffc8002", - "0x482680017ff98000", - "0x1", - "0x482680017ffa8000", - "0x1", - "0x482a80007ffb8000", - "0x482a80007ffc8000", - "0x482680017ffd8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffea", - "0x208b7fff7fff7ffe", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe1", - "0x484680017ffb8000", - "0xa", - "0x482480017fff8000", - "0xc", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffc7fff8000", - "0x48307ffc7ff98000", - "0x480a7ffb7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffdc", - "0x402a7ffc7ffd7fff", - "0x40b7ffd7fff7fff", - "0x208b7fff7fff7ffe", - "0x48297ffb80007ffc", - "0x48487ffd80007fff", - "0x400280007ffa7fff", - "0x482680017ffa8000", - "0x1", - "0x208b7fff7fff7ffe", - "0x20780017fff7ffd", - "0x4", - "0x480a7ff97fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ff97fff8000", - "0x480280007ffa8000", - "0x480280007ffb8000", - "0x480280007ffc8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff3", - "0x482680017ffa8000", - "0x1", - "0x482680017ffb8000", - "0x1", - "0x482680017ffc8000", - "0x1", - "0x482680017ffd8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffef", - "0x208b7fff7fff7ffe", - "0x480680017fff8000", - "0x0", - "0x480680017fff8000", - "0x0", - "0x480680017fff8000", - "0x0", - "0x480a7ffd7fff8000", - "0x480a7ffb7fff8000", - "0x40780017fff7fff", - "0x1", - "0x20680017fff7fff", - "0x4", - "0x10780017fff7fff", - "0x3a", - "0x480080007ffd8000", - "0x48307fff7ff98000", - "0x400080007ffc7fff", - "0x480080017ffb8000", - "0x48307fff7ff88000", - "0x400080017ffa7fff", - "0x400080027ffa7ff8", - "0x480080037ffa8000", - "0x480080027ff88000", - "0x48307fff7ffe8000", - "0x400080067ff77fff", - "0x480080047ff78000", - "0x480080037ff58000", - "0x48307fff7ffe8000", - "0x400080077ff47fff", - "0x480080057ff48000", - "0x400080087ff37fff", - "0x480080097ff38000", - "0x480080047ff18000", - "0x48307fff7ffe8000", - "0x4000800c7ff07fff", - "0x4800800a7ff08000", - "0x480080057fee8000", - "0x48307fff7ffe8000", - "0x4000800d7fed7fff", - "0x4800800b7fed8000", - "0x4000800e7fec7fff", - "0x4800800f7fec8000", - "0x480080067fea8000", - "0x48307fff7ffe8000", - "0x400080127fe97fff", - "0x480080107fe98000", - "0x480080077fe78000", - "0x48307fff7ffe8000", - "0x400080137fe67fff", - "0x480080117fe68000", - "0x400080147fe57fff", - "0x480080157fe58000", - "0x480080087fe38000", - "0x48307fff7ffe8000", - "0x400080187fe27fff", - "0x480080167fe28000", - "0x480080097fe08000", - "0x48307fff7ffe8000", - "0x400080197fdf7fff", - "0x480080177fdf8000", - "0x4000801a7fde7fff", - "0x4800801b7fde8000", - "0x4800801c7fdd8000", - "0x4800801d7fdc8000", - "0x482480017fda8000", - "0xa", - "0x482480017fda8000", - "0x1e", - "0x10780017fff7fff", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc5", - "0x40780017fff7fff", - "0x1", - "0x20680017fff7fff", - "0x4", - "0x10780017fff7fff", - "0x12", - "0x480080007ffc8000", - "0x48307fff7ff88000", - "0x400080007ffb7fff", - "0x480080017ffa8000", - "0x48307fff7ff78000", - "0x400080017ff97fff", - "0x400080027ff97ff7", - "0x480080037ff98000", - "0x480080047ff88000", - "0x480080057ff78000", - "0x482480017ff58000", - "0x2", - "0x482480017ff58000", - "0x6", - "0x10780017fff7fff", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffaf", - "0x482a7ffc7ffd8000", - "0x48307ffb80007fff", - "0x20680017fff7fff", - "0xb", - "0x482480017ff78000", - "0x1", - "0x400080007ffa7fff", - "0x400080017ffa7ff7", - "0x400080027ffa7ff8", - "0x482480017ffa8000", - "0x6", - "0x480080037ff98000", - "0x208b7fff7fff7ffe", - "0x400680017fff7fff", - "0x1", - "0x480080007ffa8000", - "0x48307fff7ff68000", - "0x400080007ff97fff", - "0x482480017ff68000", - "0x1", - "0x400080017ff87fff", - "0x400080027ff87ff6", - "0x482480017ff88000", - "0x6", - "0x480080037ff78000", - "0x208b7fff7fff7ffe", - "0x480280007ffd8000", - "0x48327fff7ffd8000", - "0x480a7ffc7fff8000", - "0x480080007ffe8000", - "0x48007fff7ffd8000", - "0x480080007ffd7fff", - "0x400080017ffc7ffd", - "0x482480017ffb8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x482480017ffb8000", - "0x3", - "0x480080027ffa8000", - "0x40287ffd7ffc7ffd", - "0x20680017fff7ffc", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff8", - "0x208b7fff7fff7ffe", - "0x482680017ffd8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x20680017fff7fff", - "0xc", - "0x480a7ffb7fff8000", - "0x480280007ffc8000", - "0x482680017ffc8000", - "0x1", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff73", - "0x480a7ffa7fff8000", - "0x48127ffd7fff8000", - "0x48127ffd7fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ffa7fff8000", - "0x480a7ffc7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe1", - "0x48127ffe7fff8000", - "0x480a7ffb7fff8000", - "0x48127ffd7fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x1a", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff18", - "0x40137ffe7fff8000", - "0x400380007ff98002", - "0x480680017fff8000", - "0x0", - "0x4002800180017fff", - "0x480280017ff98000", - "0x480280077ff98000", - "0x480a80017fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffde", - "0x4002800180027fff", - "0x4027800180018003", - "0x4", - "0x4003800380018004", - "0x482a800480038000", - "0x4802800280018000", - "0x40317fff7ffe8005", - "0x4027800180028006", - "0x2", - "0x40137ffb7fff8007", - "0x400380027ff98008", - "0x400380037ff98009", - "0x400380047ff9800a", - "0x400380057ff9800b", - "0x400380067ff9800c", - "0x40137ffc7fff800d", - "0x400380087ff9800e", - "0x480a7ffb7fff8000", - "0x4826800180008000", - "0x6", - "0x480680017fff8000", - "0x9", - "0x480a80037fff8000", - "0x480a80047fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff13", - "0x1088800580018000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffef1", - "0x402a8004800f7fff", - "0x480a7ffb7fff8000", - "0x4826800180008000", - "0x10", - "0x480a80037fff8000", - "0x480a800f7fff8000", - "0x480680017fff8000", - "0x9", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffeec", - "0x402a800380047fff", - "0x480a7ffa7fff8000", - "0x4826800180008000", - "0x6", - "0x4826800180008000", - "0x10", - "0x480a7ffc7fff8000", - "0x480680017fff8000", - "0x9", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff11", - "0x402b800280198010", - "0x4003800080028019", - "0x4826800180008000", - "0x10", - "0x48127ffe7fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x1d", - "0x402780017ff58001", - "0x1", - "0x400b7ff67fff8002", - "0x400b80007fff8003", - "0x400b7ff87fff8004", - "0x400b7ff97fff8005", - "0x400b7ffa7fff8006", - "0x400b7ffb7fff8007", - "0x400b7ffc7fff8008", - "0x400b7ffd7fff8009", - "0x400780017fff800a", - "0x6f7574707574", - "0x400780017fff800b", - "0x706564657273656e", - "0x400780017fff800c", - "0x72616e67655f636865636b", - "0x400780017fff800d", - "0x6563647361", - "0x400780017fff800e", - "0x62697477697365", - "0x400780017fff800f", - "0x65635f6f70", - "0x400780017fff8010", - "0x6b656363616b", - "0x400780017fff8011", - "0x706f736569646f6e", - "0x400780017fff8012", - "0x72616e67655f636865636b3936", - "0x400780017fff8013", - "0x1", - "0x400780017fff8014", - "0x3", - "0x400780017fff8015", - "0x1", - "0x400780017fff8016", - "0x2", - "0x400780017fff8017", - "0x5", - "0x400780017fff8018", - "0x7", - "0x400780017fff8019", - "0x10", - "0x400780017fff801a", - "0x6", - "0x400780017fff801b", - "0x1", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffea3", - "0x482480017ffe8000", - "0x1", - "0x480a7ff77fff8000", - "0x482480017ffc8000", - "0xa", - "0x482480017ffb8000", - "0x13", - "0x480280007ff58000", - "0x1104800180018000", - "0x24", - "0x400a80007fff7fff", - "0x40137ffe7fff801c", - "0x48028002801c8000", - "0x48307ffe80007fff", - "0x480680017fff8000", - "0x40", - "0x1104800180018000", - "0xc", - "0x48028000801c8000", - "0x48028001801c8000", - "0x48028002801c8000", - "0x48028003801c8000", - "0x48028004801c8000", - "0x48028005801c8000", - "0x48028006801c8000", - "0x48028007801c8000", - "0x48028008801c8000", - "0x208b7fff7fff7ffe", - "0x20780017fff7ffd", - "0x5", - "0x400780017fff7ffc", - "0x0", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x1", - "0x48307fff7fff8000", - "0x48317fff80007ffc", - "0x40507fff7fff7fff", - "0x48127ffd7fff8000", - "0x482680017ffd8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff4", - "0x208b7fff7fff7ffe", - "0x20780017fff7ffd", - "0x5", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x1", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x48127ffb7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff50", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x482680017ffd8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffef", - "0x208b7fff7fff7ffe", - "0x400380007ffc7ffd", - "0x482680017ffc8000", - "0x1", - "0x208b7fff7fff7ffe", - "0x480a7ffb7fff8000", - "0x48297ffc80007ffd", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffb", - "0x208b7fff7fff7ffe", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff6", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff6", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x1", - "0x480a7ff97fff8000", - "0x480a80007fff8000", - "0x482680017ffc8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff2", - "0x484a80007ffb8000", - "0x48327fff7ffa8000", - "0x400180007fff7ffd", - "0x48127ffd7fff8000", - "0x48127ffe7fff8000", - "0x208b7fff7fff7ffe", - "0x400380007ffb7ffc", - "0x400380017ffb7ffd", - "0x482680017ffb8000", - "0x3", - "0x480280027ffb8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x2", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe38", - "0x400780017fff8000", - "0x0", - "0x400780017fff8001", - "0x0", - "0x48127ffe7fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x2", - "0x480a7ffa7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x480280007ffb8000", - "0x1104800180018000", - "0x10", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe28", - "0x40137ffd7fff8000", - "0x480280017ffb8000", - "0x40297ffd7fff8001", - "0x48127ffb7fff8000", - "0x48127ffc7fff8000", - "0x208b7fff7fff7ffe", - "0x480a7ffc7fff8000", - "0x480280007ffd8000", - "0x480280017ffd8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffde", - "0x208b7fff7fff7ffe", - "0x20780017fff7ffc", - "0x5", - "0x480a7ffa7fff8000", - "0x480a7ffd7fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x1", - "0x482680017ffc8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x40337fff7ffb8000", - "0x480a7ffb7fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffd7fff8000", - "0x48317ffd80008000", - "0x400080007ffd7ffe", - "0x480080007ffc8000", - "0x400080017ffc7fff", - "0x482480017ffb8000", - "0x1", - "0x482480017ffb8000", - "0x3", - "0x480080027ffa8000", - "0x20680017fff7ffb", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff8", - "0x208b7fff7fff7ffe", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc8", - "0x480a7ffb7fff8000", - "0x48127ffe7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffcc", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffda", - "0x208b7fff7fff7ffe", - "0x20780017fff7ffd", - "0x3", - "0x208b7fff7fff7ffe", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480080007fff8000", - "0x400080007ffd7fff", - "0x482480017ffd8001", - "0x1", - "0x482480017ffd8001", - "0x1", - "0xa0680017fff7ffe", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffb", - "0x402a7ffc7ffd7fff", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0xb", - "0x480a80007fff8000", - "0x480a7ff67fff8000", - "0x480a7ff77fff8000", - "0x480a7ff87fff8000", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x480a7ffd7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff0a", - "0x40137ff97fff8001", - "0x40137ffa7fff8002", - "0x40137ffb7fff8003", - "0x40137ffc7fff8004", - "0x40137ffd7fff8005", - "0x40137ffe7fff8006", - "0x40137fff7fff8007", - "0x40137ff77fff8008", - "0x480a7ff57fff8000", - "0x48127ff77fff8000", - "0x480a80097fff8000", - "0x1104800180018000", - "0x45", - "0x40137ffe7fff800a", - "0x482480017ffe8000", - "0x1", - "0x48127ffe7fff8000", - "0x480a80067fff8000", - "0x480a80017fff8000", - "0x480680017fff8000", - "0x0", - "0x4826800180008000", - "0x1", - "0x480a80097fff8000", - "0x4802800080008000", - "0x1104800180018000", - "0xe", - "0x40137fff7fff8008", - "0x40028000800a7ffe", - "0x48127ffa7fff8000", - "0x48127ffa7fff8000", - "0x48127ffb7fff8000", - "0x480a80027fff8000", - "0x480a80037fff8000", - "0x480a80047fff8000", - "0x480a80057fff8000", - "0x48127ff57fff8000", - "0x480a80077fff8000", - "0x208b7fff7fff7ffe", - "0x20780017fff7ffd", - "0x9", - "0x480a7ff67fff8000", - "0x480a7ff77fff8000", - "0x480a7ff87fff8000", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x0", - "0x40780017fff7fff", - "0x1", - "0x20680017fff7fff", - "0xd", - "0x480a7ff67fff8000", - "0x480a7ff77fff8000", - "0x480a7ff87fff8000", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x1104800180018000", - "0x23", - "0x10780017fff7fff", - "0xb", - "0x480a7ff67fff8000", - "0x480a7ff77fff8000", - "0x480a7ff87fff8000", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x480a7ffb7fff8000", - "0x480a7ffc7fff8000", - "0x1104800180018000", - "0x46", - "0x480a7ffc7fff8000", - "0x482680017ffd8000", - "0x800000000000011000000000000000000000000000000000000000000000000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffdb", - "0x208b7fff7fff7ffe", - "0x480280007ffd8000", - "0x400280007ffb7fff", - "0x480a7ffc7fff8000", - "0x480280027ffd8000", - "0x480280017ffd8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff85", - "0x400280017ffb7fff", - "0x482680017ffb8000", - "0x2", - "0x48127ffd7fff8000", - "0x208b7fff7fff7ffe", - "0x482680017ffd8000", - "0x2", - "0x480a7ffd7fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x4", - "0x480a7ff97fff8000", - "0x480a80017fff8000", - "0x480a80007fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffdc0", - "0x480a7ffc7fff8000", - "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff5", - "0x480680017fff8000", - "0x4", - "0x400080007ffe7fff", - "0x480a7ffa7fff8000", - "0x480280027ffd8000", - "0x480680017fff8000", - "0x1", - "0x480280017ffd8000", - "0x480080017ffa8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff1a", - "0x480280007ffd8000", - "0x400080007fdd7fff", - "0x400080017fdd7fd9", - "0x402580017fdd8002", - "0x2", - "0x400b80007fff8003", - "0x480a7ff77fff8000", - "0x480a7ff87fff8000", - "0x48127fd67fff8000", - "0x48127ffa7fff8000", - "0x480a7ffb7fff8000", - "0x4826800180008000", - "0x1", - "0x480a7ffd7fff8000", - "0x4802800080008000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffa4", - "0x402a800180037fff", - "0x48127ffa7fff8000", - "0x48127ffa7fff8000", - "0x48127ffa7fff8000", - "0x48127ffa7fff8000", - "0x48127ffa7fff8000", - "0x480a80027fff8000", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x2", - "0x480a7ffc7fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffcc", - "0x40137ffe7fff8000", - "0x480080007fff8000", - "0x400280007ff77fff", - "0x480080017ffe8000", - "0x400280017ff77fff", - "0x480080007ffd8000", - "0x402580017fff8001", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffff", - "0x482680017ff78000", - "0x2", - "0x480a80007fff8000", - "0x480a80017fff8000", - "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff46", - "0x482680017ff78000", - "0x2", - "0x482880017fff8000", - "0x480a7ff87fff8000", - "0x480a7ff97fff8000", - "0x480a7ffa7fff8000", - "0x482680017ffb8000", - "0x1", - "0x482a800180008000", - "0x208b7fff7fff7ffe" - ], - "debug_info": { - "file_contents": {}, - "instruction_locations": { - "0": { - "accessible_scopes": [ - "starkware.cairo.lang.compiler.lib.registers", - "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 0, - "offset": 0 - }, - "reference_ids": {} - }, - "hints": [], - "inst": { - "end_col": 73, - "end_line": 7, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" - }, - "start_col": 5, - "start_line": 7 - } - }, - "1": { - "accessible_scopes": [ - "starkware.cairo.lang.compiler.lib.registers", - "starkware.cairo.lang.compiler.lib.registers.get_ap" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 1, - "offset": 0 - }, - "reference_ids": {} - }, - "hints": [], - "inst": { - "end_col": 43, - "end_line": 16, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" - }, - "start_col": 28, - "start_line": 16 - } - }, - "3": { - "accessible_scopes": [ - "starkware.cairo.lang.compiler.lib.registers", - "starkware.cairo.lang.compiler.lib.registers.get_ap" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 1, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val": 0, - "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val": 1 - } - }, - "hints": [], - "inst": { - "end_col": 30, - "end_line": 17, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" - }, - "start_col": 20, - "start_line": 17 - } - }, - "5": { - "accessible_scopes": [ - "starkware.cairo.lang.compiler.lib.registers", - "starkware.cairo.lang.compiler.lib.registers.get_ap" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 1, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val": 0, - "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val": 1 - } - }, - "hints": [], - "inst": { - "end_col": 32, - "end_line": 17, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/lang/compiler/lib/registers.cairo" - }, - "start_col": 5, - "start_line": 17 - } - }, - "6": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 30, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 5, - "start_line": 30 - } - }, - "8": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 30, - "end_line": 21, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 58, - "end_line": 32, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 40, - "start_line": 32 - }, - "While expanding the reference 'selected_encodings' in:" - ], - "start_col": 5, - "start_line": 21 - } - }, - "9": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 60, - "end_line": 32, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 9, - "start_line": 32 - } - }, - "10": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 18, - "end_line": 35, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 5, - "start_line": 35 - } - }, - "12": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 46, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 5, - "start_line": 38 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 53, - "end_line": 48, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 5, - "start_line": 48 - } - }, - "13": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 50, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 5, - "start_line": 50 - } - }, - "14": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 51, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 5, - "start_line": 51 - } - }, - "15": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 5, - "start_line": 53 - } - }, - "17": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 5, - "start_line": 53 - } - }, - "19": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 53, - "end_line": 56, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 9, - "start_line": 56 - } - }, - "20": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 43, - "end_line": 58, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 9, - "start_line": 58 - } - }, - "21": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 23, - "start_line": 65 - } - }, - "23": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 30, - "end_line": 66, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 18, - "start_line": 66 - } - }, - "25": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 63, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 28, - "start_line": 67 - } - }, - "26": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 53, - "end_line": 68, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 23, - "start_line": 68 - } - }, - "27": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 34, - "end_line": 69, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 20, - "start_line": 69 - } - }, - "29": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 12, - "start_line": 64 - } - }, - "31": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 3, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": 8, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": 9, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/inner_select_builtins.cairo" - }, - "start_col": 5, - "start_line": 64 - } - }, - "32": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 4, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [], - "inst": { - "end_col": 35, - "end_line": 23, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 17, - "start_line": 23 - } - }, - "34": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 4, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [ - { - "location": { - "end_col": 75, - "end_line": 26, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 5, - "start_line": 26 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 77, - "end_line": 19, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 46, - "end_line": 21, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 57, - "end_line": 25, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 36, - "end_line": 31, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 23, - "start_line": 31 - }, - "While expanding the reference 'selected_ptrs' in:" - ], - "start_col": 40, - "start_line": 25 - }, - "While expanding the reference 'total_func_memory' in:" - ], - "start_col": 29, - "start_line": 21 - }, - "While expanding the reference 'inner_func_memory' in:" - ], - "start_col": 29, - "start_line": 19 - } - }, - "36": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 4, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [], - "inst": { - "end_col": 79, - "end_line": 21, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 57, - "end_line": 25, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 36, - "end_line": 31, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 23, - "start_line": 31 - }, - "While expanding the reference 'selected_ptrs' in:" - ], - "start_col": 40, - "start_line": 25 - }, - "While expanding the reference 'total_func_memory' in:" - ], - "start_col": 29, - "start_line": 21 - } - }, - "38": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 4, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [], - "inst": { - "end_col": 25, - "end_line": 7, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 36, - "end_line": 28, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 23, - "start_line": 28 - }, - "While expanding the reference 'all_encodings' in:" - ], - "start_col": 5, - "start_line": 7 - } - }, - "39": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 4, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 8, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 26, - "end_line": 29, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 18, - "start_line": 29 - }, - "While expanding the reference 'all_ptrs' in:" - ], - "start_col": 5, - "start_line": 8 - } - }, - "40": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 4, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [], - "inst": { - "end_col": 30, - "end_line": 10, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 46, - "end_line": 30, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 28, - "start_line": 30 - }, - "While expanding the reference 'selected_encodings' in:" - ], - "start_col": 5, - "start_line": 10 - } - }, - "41": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 4, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [], - "inst": { - "end_col": 57, - "end_line": 25, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 36, - "end_line": 31, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 23, - "start_line": 31 - }, - "While expanding the reference 'selected_ptrs' in:" - ], - "start_col": 25, - "start_line": 25 - } - }, - "42": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 4, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [], - "inst": { - "end_col": 25, - "end_line": 9, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 34, - "end_line": 32, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 20, - "start_line": 32 - }, - "While expanding the reference 'n_all_builtins' in:" - ], - "start_col": 5, - "start_line": 9 - } - }, - "43": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 4, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 33, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 21, - "start_line": 27 - } - }, - "45": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 5, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [ - { - "location": { - "end_col": 26, - "end_line": 34, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 5, - "start_line": 34 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 80, - "end_line": 36, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 5, - "start_line": 36 - } - }, - "46": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 5, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [], - "inst": { - "end_col": 30, - "end_line": 38, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 5, - "start_line": 38 - } - }, - "47": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 6, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - }, - "hints": [], - "inst": { - "end_col": 8, - "end_line": 39, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/select_input_builtins.cairo" - }, - "start_col": 5, - "start_line": 39 - } - }, - "48": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 7, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 25 - } - }, - "hints": [], - "inst": { - "end_col": 54, - "end_line": 16, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 20, - "start_line": 16 - } - }, - "49": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 7, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 25 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 17, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 23, - "start_line": 17 - } - }, - "50": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 7, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": 27, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 25 - } - }, - "hints": [], - "inst": { - "end_col": 32, - "end_line": 18, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 5, - "start_line": 18 - } - }, - "51": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 7, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": 27, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 28 - } - }, - "hints": [], - "inst": { - "end_col": 46, - "end_line": 19, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 38, - "end_line": 11, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 20, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 5, - "start_line": 20 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 23, - "start_line": 11 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 27, - "start_line": 19 - } - }, - "53": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 7, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": 24, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": 26, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": 27, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": 23, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": 22, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": 28 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 20, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 5, - "start_line": 20 - } - }, - "54": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 40, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 5, - "start_line": 40 - } - }, - "56": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 37, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 39, - "end_line": 37, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 19, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 9, - "start_line": 41 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 24, - "start_line": 37 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 24, - "start_line": 37 - } - }, - "57": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 - } - }, - "hints": [], - "inst": { - "end_col": 19, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 9, - "start_line": 41 - } - }, - "58": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 37, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 38, - "end_line": 11, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "parent_location": [ - { - "end_col": 6, - "end_line": 48, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 5, - "start_line": 44 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 23, - "start_line": 11 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 24, - "start_line": 37 - } - }, - "59": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 - } - }, - "hints": [], - "inst": { - "end_col": 58, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 26, - "start_line": 45 - } - }, - "60": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 - } - }, - "hints": [], - "inst": { - "end_col": 56, - "end_line": 46, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 25, - "start_line": 46 - } - }, - "61": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 - } - }, - "hints": [], - "inst": { - "end_col": 55, - "end_line": 47, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 31, - "start_line": 47 - } - }, - "62": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 33 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 48, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 5, - "start_line": 44 - } - }, - "64": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 - } - }, - "hints": [], - "inst": { - "end_col": 48, - "end_line": 51, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 27, - "start_line": 51 - } - }, - "66": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 - } - }, - "hints": [], - "inst": { - "end_col": 46, - "end_line": 52, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 26, - "start_line": 52 - } - }, - "68": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 11 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 - } - }, - "hints": [], - "inst": { - "end_col": 58, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 32, - "start_line": 53 - } - }, - "70": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 12 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 - } - }, - "hints": [], - "inst": { - "end_col": 34, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 20, - "start_line": 54 - } - }, - "72": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 8, - "offset": 13 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 34 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 55, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 12, - "start_line": 50 - } - }, - "74": { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.validate_builtins", - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 9, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": 31, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": 32, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": 30, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": 29, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": 35 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 55, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/builtin_selection/validate_builtins.cairo" - }, - "start_col": 5, - "start_line": 50 - } - }, - "75": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38 - } - }, - "hints": [], - "inst": { - "end_col": 46, - "end_line": 34, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 45, - "start_line": 34 - } - }, - "77": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38 - } - }, - "hints": [], - "inst": { - "end_col": 52, - "end_line": 34, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 51, - "start_line": 34 - } - }, - "79": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38 - } - }, - "hints": [], - "inst": { - "end_col": 58, - "end_line": 34, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 57, - "start_line": 34 - } - }, - "81": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 37, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 81, - "end_line": 28, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 32, - "end_line": 35, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 24, - "start_line": 35 - }, - "While expanding the reference 'elements' in:" - ], - "start_col": 66, - "start_line": 28 - } - }, - "82": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 38, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 55, - "end_line": 28, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 40, - "end_line": 36, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 28, - "start_line": 36 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 25, - "start_line": 28 - } - }, - "83": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [ - { - "location": { - "end_col": 59, - "end_line": 39, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 39 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 59, - "end_line": 39, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 39 - } - }, - "85": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 39, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 39 - } - }, - "87": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 39, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 39 - } - }, - "89": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 27, - "start_line": 41 - } - }, - "90": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 16, - "start_line": 41 - } - }, - "91": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 42, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 40 - } - }, - "92": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 54, - "start_line": 41 - } - }, - "93": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 43, - "start_line": 41 - } - }, - "94": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 42, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 40 - } - }, - "95": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 42, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 40 - } - }, - "96": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 47, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 16, - "start_line": 47 - } - }, - "97": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 11 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 47, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 27, - "start_line": 47 - } - }, - "98": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 12 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 47, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 16, - "start_line": 47 - } - }, - "99": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 13 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 48, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 46 - } - }, - "100": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 13 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 47, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 43, - "start_line": 47 - } - }, - "101": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 14 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 47, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 54, - "start_line": 47 - } - }, - "102": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 15 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 47, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 43, - "start_line": 47 - } - }, - "103": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 16 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 48, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 46 - } - }, - "104": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 16 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 - } - }, - "hints": [], - "inst": { - "end_col": 78, - "end_line": 47, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 70, - "start_line": 47 - } - }, - "105": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 17 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 49, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 48 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 48, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 46 - } - }, - "106": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 17 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 16, - "start_line": 53 - } - }, - "107": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 18 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 27, - "start_line": 53 - } - }, - "108": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 19 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 16, - "start_line": 53 - } - }, - "109": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 20 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 52 - } - }, - "110": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 20 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 43, - "start_line": 53 - } - }, - "111": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 21 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 54, - "start_line": 53 - } - }, - "112": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 22 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 43, - "start_line": 53 - } - }, - "113": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 23 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 52 - } - }, - "114": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 23 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 - } - }, - "hints": [], - "inst": { - "end_col": 78, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 70, - "start_line": 53 - } - }, - "115": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 24 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 58, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 57 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 52 - } - }, - "116": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 24 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 59, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 16, - "start_line": 59 - } - }, - "117": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 25 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 59, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 27, - "start_line": 59 - } - }, - "118": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 26 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 59, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 16, - "start_line": 59 - } - }, - "119": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 27 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 60, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 58 - } - }, - "120": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 27 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 59, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 43, - "start_line": 59 - } - }, - "121": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 28 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 59, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 54, - "start_line": 59 - } - }, - "122": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 59, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 43, - "start_line": 59 - } - }, - "123": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 30 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 60, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 58 - } - }, - "124": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 30 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 - } - }, - "hints": [], - "inst": { - "end_col": 78, - "end_line": 59, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 70, - "start_line": 59 - } - }, - "125": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 31 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 67, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 66 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 60, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 58 - } - }, - "126": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 31 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 16, - "start_line": 65 - } - }, - "127": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 32 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 27, - "start_line": 65 - } - }, - "128": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 33 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 16, - "start_line": 65 - } - }, - "129": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 34 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 66, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 64 - } - }, - "130": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 34 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 43, - "start_line": 65 - } - }, - "131": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 35 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 54, - "start_line": 65 - } - }, - "132": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 36 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 43, - "start_line": 65 - } - }, - "133": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 37 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 66, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 64 - } - }, - "134": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 37 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 - } - }, - "hints": [], - "inst": { - "end_col": 78, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 70, - "start_line": 65 - } - }, - "135": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 38 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 76, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 75 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 66, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 64 - } - }, - "136": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 38 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 84 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 30, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 25, - "start_line": 70 - }, - "While expanding the reference 'state' in:" - ], - "start_col": 21, - "start_line": 67 - } - }, - "137": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 39 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 84 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 30, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 25, - "start_line": 70 - }, - "While expanding the reference 'state' in:" - ], - "start_col": 21, - "start_line": 67 - } - }, - "138": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 40 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 84 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 30, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 25, - "start_line": 70 - }, - "While expanding the reference 'state' in:" - ], - "start_col": 21, - "start_line": 67 - } - }, - "139": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 41 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 86 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 71, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 29, - "start_line": 71 - } - }, - "141": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 42 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 87, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 85, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 86 - } - }, - "hints": [], - "inst": { - "end_col": 63, - "end_line": 68, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 44, - "end_line": 72, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 32, - "start_line": 72 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 28, - "start_line": 68 - } - }, - "143": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 43 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": 53, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": 54, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": 55, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": 56, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": 59, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": 60, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": 61, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": 62, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": 63, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": 64, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": 65, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": 68, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": 69, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": 70, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": 71, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": 72, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": 73, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": 74, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": 77, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": 78, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": 44, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": 79, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": 80, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": 81, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": 82, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": 83, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": 45, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": 46, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": 47, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": 50, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": 51, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": 52, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 87, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 88, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 86 - } - }, - "hints": [], - "inst": { - "end_col": 17, - "end_line": 73, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 73 - } - }, - "145": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [ - { - "location": { - "end_col": 58, - "end_line": 76, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 76 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 58, - "end_line": 76, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 76 - } - }, - "147": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 76, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 76 - } - }, - "149": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 76, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 76 - } - }, - "151": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 78, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 27, - "start_line": 78 - } - }, - "152": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 78, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 16, - "start_line": 78 - } - }, - "153": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 77 - } - }, - "154": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 78, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 54, - "start_line": 78 - } - }, - "155": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 78, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 43, - "start_line": 78 - } - }, - "156": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 11 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 77 - } - }, - "157": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 11 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 11, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 77 - } - }, - "158": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 11 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 94 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 80, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 30, - "end_line": 83, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 25, - "start_line": 83 - }, - "While expanding the reference 'state' in:" - ], - "start_col": 21, - "start_line": 80 - } - }, - "159": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 12 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 94 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 80, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 30, - "end_line": 83, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 25, - "start_line": 83 - }, - "While expanding the reference 'state' in:" - ], - "start_col": 21, - "start_line": 80 - } - }, - "160": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 13 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 94 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 80, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 30, - "end_line": 83, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 25, - "start_line": 83 - }, - "While expanding the reference 'state' in:" - ], - "start_col": 21, - "start_line": 80 - } - }, - "161": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 14 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 96 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 84, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 29, - "start_line": 84 - } - }, - "163": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 15 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 97, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 95, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 96 - } - }, - "hints": [], - "inst": { - "end_col": 63, - "end_line": 81, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 44, - "end_line": 85, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 32, - "start_line": 85 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 28, - "start_line": 81 - } - }, - "165": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 16 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": 90, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": 91, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": 92, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": 93, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 97, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 98, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 96 - } - }, - "hints": [], - "inst": { - "end_col": 17, - "end_line": 86, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 86 - } - }, - "167": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 29, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 29, - "end_line": 89, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 17, - "start_line": 89 - }, - "While expanding the reference 'elements_end' in:" - ], - "start_col": 25, - "start_line": 29 - } - }, - "168": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 89, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 17, - "start_line": 89 - } - }, - "169": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 91, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 91 - } - }, - "171": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 73, - "end_line": 93, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 61, - "start_line": 93 - } - }, - "173": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 101, - "end_line": 93, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 93 - } - }, - "174": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 101, - "end_line": 93, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 93 - } - }, - "175": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 101, - "end_line": 93, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 93 - } - }, - "176": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 106, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 105, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 63, - "end_line": 95, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 55, - "end_line": 28, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 26, - "end_line": 96, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 96 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 25, - "start_line": 28 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 28, - "start_line": 95 - } - }, - "178": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 11 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 106, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 105, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 94, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 24, - "end_line": 96, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 21, - "start_line": 96 - }, - "While expanding the reference 'res' in:" - ], - "start_col": 19, - "start_line": 94 - } - }, - "179": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 12 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": 104, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 106, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 105, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 26, - "end_line": 96, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 9, - "start_line": 96 - } - }, - "180": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 18, - "end_line": 99, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 99 - } - }, - "182": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 34, - "end_line": 102, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 23, - "start_line": 102 - } - }, - "183": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 34, - "end_line": 102, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 12, - "start_line": 102 - } - }, - "184": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 11 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 103, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 101 - } - }, - "185": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 11 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 102, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 39, - "start_line": 102 - } - }, - "187": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 12 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 103, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 101 - } - }, - "188": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 12 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 103, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 101 - } - }, - "189": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 12 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 111, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 110, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 59, - "end_line": 105, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 55, - "end_line": 28, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 106, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 106 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 25, - "start_line": 28 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 24, - "start_line": 105 - } - }, - "191": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 13 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 111, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 110, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 104, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 106, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 17, - "start_line": 106 - }, - "While expanding the reference 'res' in:" - ], - "start_col": 15, - "start_line": 104 - } - }, - "192": { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 14 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": 89, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": 102, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": 107, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": 108, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": 109, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 103, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 111, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": 110, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - }, - "hints": [], - "inst": { - "end_col": 22, - "end_line": 106, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "start_col": 5, - "start_line": 106 - } - }, - "193": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 15, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 27, - "start_line": 15 - } - }, - "194": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 - } - }, - "hints": [], - "inst": { - "end_col": 50, - "end_line": 16, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 28, - "start_line": 16 - } - }, - "195": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 8, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "parent_location": [ - { - "end_col": 49, - "end_line": 19, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 41, - "start_line": 19 - }, - "While expanding the reference 'hash_ptr' in:" - ], - "start_col": 17, - "start_line": 8 - } - }, - "196": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113 - } - }, - "hints": [], - "inst": { - "end_col": 74, - "end_line": 19, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 60, - "start_line": 19 - } - }, - "197": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, - "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, - "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116 - } - }, - "hints": [], - "inst": { - "end_col": 49, - "end_line": 26, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 24, - "start_line": 26 - } - }, - "198": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, - "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, - "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, - "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, - "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 30, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 5, - "start_line": 30 - } - }, - "199": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, - "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, - "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, - "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, - "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 31, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 5, - "start_line": 31 - } - }, - "200": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, - "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, - "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, - "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, - "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 35, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 18, - "start_line": 35 - } - }, - "202": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, - "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, - "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, - "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, - "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 - } - }, - "hints": [], - "inst": { - "end_col": 56, - "end_line": 36, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 18, - "start_line": 36 - } - }, - "204": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, - "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, - "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, - "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, - "starkware.cairo.common.hash_chain.hash_chain.new_data": 119 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 37, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 18, - "start_line": 37 - } - }, - "205": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, - "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, - "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, - "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, - "starkware.cairo.common.hash_chain.hash_chain.new_data": 119, - "starkware.cairo.common.hash_chain.hash_chain.next_frame": 121 - } - }, - "hints": [], - "inst": { - "end_col": 56, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 5, - "start_line": 41 - } - }, - "206": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, - "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 113, - "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, - "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, - "starkware.cairo.common.hash_chain.hash_chain.new_data": 119, - "starkware.cairo.common.hash_chain.hash_chain.next_frame": 121 - } - }, - "hints": [], - "inst": { - "end_col": 45, - "end_line": 42, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 5, - "start_line": 42 - } - }, - "208": { - "accessible_scopes": [ - "starkware.cairo.common.hash_chain", - "starkware.cairo.common.hash_chain.hash_chain" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 12, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.hash_chain.hash_chain.curr_frame": 117, - "starkware.cairo.common.hash_chain.hash_chain.current_hash": 118, - "starkware.cairo.common.hash_chain.hash_chain.data_length": 114, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": 112, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": 115, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": 122, - "starkware.cairo.common.hash_chain.hash_chain.loop_frame": 116, - "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": 120, - "starkware.cairo.common.hash_chain.hash_chain.new_data": 119, - "starkware.cairo.common.hash_chain.hash_chain.next_frame": 121 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 46, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_chain.cairo" - }, - "start_col": 5, - "start_line": 46 - } - }, - "209": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 13, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 26, - "end_line": 48, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 9, - "start_line": 48 - } - }, - "211": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 13, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 48, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 48 - } - }, - "213": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 13, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 85, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 66, - "end_line": 49, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 54, - "start_line": 49 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 55, - "start_line": 45 - } - }, - "214": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 13, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 34, - "end_line": 50, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 15, - "start_line": 50 - } - }, - "215": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 13, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 50, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 46, - "start_line": 50 - } - }, - "217": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 13, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 10, - "end_line": 51, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 22, - "start_line": 49 - } - }, - "219": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 14, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 53, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 53, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 28, - "end_line": 52, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 9, - "start_line": 52 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 27, - "start_line": 45 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 27, - "start_line": 45 - } - }, - "220": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 14, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 66, - "end_line": 49, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 85, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 28, - "end_line": 52, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 9, - "start_line": 52 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 55, - "start_line": 45 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 54, - "start_line": 49 - } - }, - "221": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 14, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 18, - "end_line": 49, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 26, - "end_line": 52, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 22, - "start_line": 52 - }, - "While expanding the reference 'hash' in:" - ], - "start_col": 14, - "start_line": 49 - } - }, - "222": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 14, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 129, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 128, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 52, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 9, - "start_line": 52 - } - }, - "223": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 13, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 53, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 54, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 42, - "start_line": 54 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 27, - "start_line": 45 - } - }, - "224": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 13, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 46, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 81, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 65, - "start_line": 54 - }, - "While expanding the reference 'program_data_ptr' in:" - ], - "start_col": 5, - "start_line": 46 - } - }, - "225": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 13, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 125, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 82, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 22, - "start_line": 54 - } - }, - "227": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 15, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 54, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 53, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 28, - "end_line": 55, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 9, - "start_line": 55 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 27, - "start_line": 45 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 42, - "start_line": 54 - } - }, - "228": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 15, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 85, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 85, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 28, - "end_line": 55, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 9, - "start_line": 55 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 55, - "start_line": 45 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 55, - "start_line": 45 - } - }, - "229": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 15, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 18, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 26, - "end_line": 55, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 22, - "start_line": 55 - }, - "While expanding the reference 'hash' in:" - ], - "start_col": 14, - "start_line": 54 - } - }, - "230": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 15, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": 127, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": 131, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": 130, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": 126, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": 123, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": 124 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 55, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 9, - "start_line": 55 - } - }, - "231": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 18, - "end_line": 69, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "233": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 26 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 44, - "end_line": 72, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 29, - "start_line": 72 - } - }, - "235": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 28 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 137, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 22, - "end_line": 72, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 10, - "start_line": 72 - } - }, - "236": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 28 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [ - { - "location": { - "end_col": 68, - "end_line": 76, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 76 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 50, - "end_line": 80, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 80 - } - }, - "237": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 28 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 91, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 83 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 66, - "end_line": 94, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 48, - "start_line": 94 - } - }, - "239": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 67, - "end_line": 94, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 94 - } - }, - "240": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 71, - "end_line": 97, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 53, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 102, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 22, - "start_line": 100 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 27, - "start_line": 45 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 24, - "start_line": 97 - } - }, - "241": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 30 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 75, - "end_line": 98, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 85, - "end_line": 45, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 102, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 22, - "start_line": 100 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 55, - "start_line": 45 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 24, - "start_line": 98 - } - }, - "242": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 31 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 27, - "end_line": 75, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 46, - "end_line": 101, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 30, - "start_line": 101 - }, - "While expanding the reference 'program_data_ptr' in:" - ], - "start_col": 11, - "start_line": 75 - } - }, - "243": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 32 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 94, - "end_line": 66, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 73, - "end_line": 101, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 61, - "start_line": 101 - }, - "While expanding the reference 'use_poseidon' in:" - ], - "start_col": 76, - "start_line": 66 - } - }, - "244": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 33 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 144, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 145, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 10, - "end_line": 102, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 22, - "start_line": 100 - } - }, - "246": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 106, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 106 - } - }, - "247": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 114, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 107 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 62, - "end_line": 117, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 117 - } - }, - "249": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 50, - "end_line": 118, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 118 - } - }, - "250": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 56, - "end_line": 119, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 31, - "start_line": 119 - } - }, - "251": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 123, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 120 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 55, - "end_line": 124, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 28, - "start_line": 124 - } - }, - "252": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 71, - "end_line": 126, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 126 - } - }, - "253": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 130 - } - }, - "255": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 130 - } - }, - "256": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 130 - } - }, - "257": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 130 - } - }, - "258": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 130 - } - }, - "259": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 130 - } - }, - "260": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 130 - } - }, - "261": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 130 - } - }, - "262": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 130 - } - }, - "263": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 66, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 40, - "end_line": 144, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 23, - "start_line": 144 - }, - "While expanding the reference 'builtin_encodings' in:" - ], - "start_col": 5, - "start_line": 66 - } - }, - "264": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 130, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 45, - "end_line": 145, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 19, - "start_line": 145 - }, - "While expanding the reference 'pre_execution_builtin_ptrs' in:" - ], - "start_col": 11, - "start_line": 130 - } - }, - "266": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 146, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 24, - "start_line": 146 - } - }, - "268": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 23, - "end_line": 117, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 40, - "end_line": 147, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 28, - "start_line": 147 - }, - "While expanding the reference 'builtin_list' in:" - ], - "start_col": 11, - "start_line": 117 - } - }, - "269": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 21, - "end_line": 118, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 39, - "end_line": 148, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 29, - "start_line": 148 - }, - "While expanding the reference 'n_builtins' in:" - ], - "start_col": 11, - "start_line": 118 - } - }, - "270": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 149, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 143 - } - }, - "272": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 18, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 185, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 152 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 33, - "end_line": 188, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 188 - } - }, - "273": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 19, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 194, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 191 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 28, - "end_line": 198, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 20, - "start_line": 198 - } - }, - "275": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 19, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - }, - "hints": [], - "inst": { - "end_col": 72, - "end_line": 199, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 199 - } - }, - "276": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 19, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 217, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 206 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 36, - "end_line": 66, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 40, - "end_line": 219, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 23, - "start_line": 219 - }, - "While expanding the reference 'builtin_encodings' in:" - ], - "start_col": 5, - "start_line": 66 - } - }, - "277": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 19, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 30, - "end_line": 205, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 38, - "end_line": 220, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 19, - "start_line": 220 - }, - "While expanding the reference 'return_builtin_ptrs' in:" - ], - "start_col": 11, - "start_line": 205 - } - }, - "279": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 19, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 23, - "end_line": 117, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 40, - "end_line": 221, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 28, - "start_line": 221 - }, - "While expanding the reference 'builtin_list' in:" - ], - "start_col": 11, - "start_line": 117 - } - }, - "280": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 19, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 29, - "end_line": 199, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 41, - "end_line": 222, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 23, - "start_line": 222 - }, - "While expanding the reference 'used_builtins_addr' in:" - ], - "start_col": 11, - "start_line": 199 - } - }, - "281": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 19, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 223, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 20, - "start_line": 223 - } - }, - "283": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 19, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 224, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 31, - "start_line": 218 - } - }, - "285": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 20, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [ - { - "location": { - "end_col": 26, - "end_line": 225, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 225 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 83, - "end_line": 229, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 229 - } - }, - "286": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 20, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 67, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 59, - "end_line": 232, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 39, - "start_line": 232 - }, - "While expanding the reference 'self_range_check_ptr' in:" - ], - "start_col": 47, - "start_line": 65 - } - }, - "287": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 20, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 130, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 54, - "end_line": 233, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 28, - "start_line": 233 - }, - "While expanding the reference 'pre_execution_builtin_ptrs' in:" - ], - "start_col": 11, - "start_line": 130 - } - }, - "289": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 20, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 30, - "end_line": 205, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 46, - "end_line": 234, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 27, - "start_line": 234 - }, - "While expanding the reference 'return_builtin_ptrs' in:" - ], - "start_col": 11, - "start_line": 205 - } - }, - "291": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 20, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 74, - "end_line": 66, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 54, - "end_line": 235, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 32, - "start_line": 235 - }, - "While expanding the reference 'builtin_instance_sizes' in:" - ], - "start_col": 38, - "start_line": 66 - } - }, - "292": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 20, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 236, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 20, - "start_line": 236 - } - }, - "294": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 20, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 237, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 232 - } - }, - "296": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 21, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 241, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 241 - } - }, - "297": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 21, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 242, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 242 - } - }, - "298": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 21, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 161, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 256, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 244 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 30, - "end_line": 205, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 44, - "end_line": 258, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 45, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 259, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 259 - }, - "While trying to retrieve the implicit argument 'builtin_ptrs' in:" - ], - "start_col": 19, - "start_line": 65 - }, - "While expanding the reference 'builtin_ptrs' in:" - ], - "start_col": 25, - "start_line": 258 - }, - "While expanding the reference 'return_builtin_ptrs' in:" - ], - "start_col": 11, - "start_line": 205 - } - }, - "300": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 21, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 161, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 59, - "end_line": 232, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 67, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 259, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 259 - }, - "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" - ], - "start_col": 47, - "start_line": 65 - }, - "While expanding the reference 'self_range_check_ptr' in:" - ], - "start_col": 39, - "start_line": 232 - } - }, - "301": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 21, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 161, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 259, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "start_col": 5, - "start_line": 259 - } - }, - "302": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 162, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164 - } - }, - "hints": [], - "inst": { - "end_col": 18, - "end_line": 24, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 24 - } - }, - "304": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 38, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 27 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 7, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 44 - } - }, - "306": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 44 - } - }, - "307": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 44 - } - }, - "308": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 44 - } - }, - "309": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 44 - } - }, - "310": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 44 - } - }, - "311": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 44 - } - }, - "312": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 44 - } - }, - "313": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 44 - } - }, - "314": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 57 - } - }, - "316": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 57 - } - }, - "318": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 57 - } - }, - "320": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 57 - } - }, - "322": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 57 - } - }, - "324": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 57 - } - }, - "326": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 57 - } - }, - "328": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 57 - } - }, - "330": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 57 - } - }, - "332": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "334": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "336": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "338": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "340": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "342": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "344": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "346": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "348": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 79, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "350": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 82, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 23, - "start_line": 82 - } - }, - "352": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 31 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [ - { - "location": { - "end_col": 48, - "end_line": 84, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 84 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 30, - "end_line": 44, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 44, - "end_line": 85, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 46, - "end_line": 153, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 92, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 9, - "start_line": 88 - }, - "While trying to retrieve the implicit argument 'builtin_ptrs' in:" - ], - "start_col": 20, - "start_line": 153 - }, - "While expanding the reference 'builtin_ptrs' in:" - ], - "start_col": 25, - "start_line": 85 - }, - "While expanding the reference 'builtin_ptrs_before' in:" - ], - "start_col": 11, - "start_line": 44 - } - }, - "354": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 32 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 16, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 47, - "end_line": 86, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 68, - "end_line": 153, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 92, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 9, - "start_line": 88 - }, - "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" - ], - "start_col": 48, - "start_line": 153 - }, - "While expanding the reference 'self_range_check_ptr' in:" - ], - "start_col": 32, - "start_line": 86 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 16 - } - }, - "355": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 33 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 57, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 49, - "end_line": 89, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 32, - "start_line": 89 - }, - "While expanding the reference 'builtin_encodings' in:" - ], - "start_col": 11, - "start_line": 57 - } - }, - "357": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 34 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 33, - "end_line": 69, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 59, - "end_line": 90, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 37, - "start_line": 90 - }, - "While expanding the reference 'builtin_instance_sizes' in:" - ], - "start_col": 11, - "start_line": 69 - } - }, - "359": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 35 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 40, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 28, - "end_line": 91, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 21, - "start_line": 91 - }, - "While expanding the reference 'n_tasks' in:" - ], - "start_col": 19, - "start_line": 40 - } - }, - "360": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 36 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 178, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 179, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 10, - "end_line": 92, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 9, - "start_line": 88 - } - }, - "362": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 23, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 180, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 56, - "end_line": 96, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 96 - } - }, - "363": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 23, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 180, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 53, - "end_line": 99, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 99 - } - }, - "364": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 23, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 102, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 50, - "end_line": 119, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 52, - "end_line": 120, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 29, - "start_line": 120 - }, - "While expanding the reference 'additional_range_checks' in:" - ], - "start_col": 35, - "start_line": 119 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 27, - "start_line": 102 - } - }, - "365": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 23, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 73, - "end_line": 119, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 52, - "end_line": 120, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 29, - "start_line": 120 - }, - "While expanding the reference 'additional_range_checks' in:" - ], - "start_col": 35, - "start_line": 119 - } - }, - "366": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 23, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 63, - "end_line": 120, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 61, - "start_line": 120 - } - }, - "368": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 23, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 64, - "end_line": 120, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 120 - } - }, - "370": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 24, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 54, - "end_line": 100, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 14, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 122, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 122 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 14 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 22, - "start_line": 100 - } - }, - "371": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 24, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 101, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 15, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 122, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 122 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 15 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 24, - "start_line": 101 - } - }, - "372": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 24, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 102, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 16, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 122, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 122 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 16 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 27, - "start_line": 102 - } - }, - "373": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 24, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 103, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 14, - "end_line": 17, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 122, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 122 - }, - "While trying to retrieve the implicit argument 'ecdsa_ptr' in:" - ], - "start_col": 5, - "start_line": 17 - }, - "While expanding the reference 'ecdsa_ptr' in:" - ], - "start_col": 21, - "start_line": 103 - } - }, - "374": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 24, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 43, - "end_line": 104, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 16, - "end_line": 18, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 122, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 122 - }, - "While trying to retrieve the implicit argument 'bitwise_ptr' in:" - ], - "start_col": 5, - "start_line": 18 - }, - "While expanding the reference 'bitwise_ptr' in:" - ], - "start_col": 23, - "start_line": 104 - } - }, - "375": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 24, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 105, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 14, - "end_line": 19, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 122, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 122 - }, - "While trying to retrieve the implicit argument 'ec_op_ptr' in:" - ], - "start_col": 5, - "start_line": 19 - }, - "While expanding the reference 'ec_op_ptr' in:" - ], - "start_col": 21, - "start_line": 105 - } - }, - "376": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 24, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 106, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 20, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 122, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 122 - }, - "While trying to retrieve the implicit argument 'keccak_ptr' in:" - ], - "start_col": 5, - "start_line": 20 - }, - "While expanding the reference 'keccak_ptr' in:" - ], - "start_col": 22, - "start_line": 106 - } - }, - "377": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 24, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 69, - "end_line": 107, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 35, - "end_line": 21, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 122, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 122 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 21 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 24, - "start_line": 107 - } - }, - "378": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 24, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 55, - "end_line": 108, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 22, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 122, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 122 - }, - "While trying to retrieve the implicit argument 'range_check96_ptr' in:" - ], - "start_col": 5, - "start_line": 22 - }, - "While expanding the reference 'range_check96_ptr' in:" - ], - "start_col": 29, - "start_line": 108 - } - }, - "379": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 24, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": 193, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": 192, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 187, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": 182, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 188, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 186, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 189, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 183, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 184, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 190, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 191, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 185, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": 181, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 122, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 122 - } - }, - "380": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 128, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 128 - } - }, - "382": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 129, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 9, - "start_line": 129 - } - }, - "384": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 - } - }, - "hints": [], - "inst": { - "end_col": 19, - "end_line": 130, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 9, - "start_line": 130 - } - }, - "385": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 - } - }, - "hints": [ - { - "location": { - "end_col": 50, - "end_line": 133, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 133 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 50, - "end_line": 133, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 133 - } - }, - "387": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 - } - }, - "hints": [], - "inst": { - "end_col": 45, - "end_line": 134, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 26, - "start_line": 134 - } - }, - "388": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 - } - }, - "hints": [], - "inst": { - "end_col": 46, - "end_line": 134, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 19, - "start_line": 134 - } - }, - "389": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 136, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 136 - } - }, - "390": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 - } - }, - "hints": [], - "inst": { - "end_col": 21, - "end_line": 133, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 44, - "end_line": 137, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 36, - "start_line": 137 - }, - "While expanding the reference 'num_div2' in:" - ], - "start_col": 13, - "start_line": 133 - } - }, - "391": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 - } - }, - "hints": [], - "inst": { - "end_col": 63, - "end_line": 137, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 53, - "start_line": 137 - } - }, - "393": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 - } - }, - "hints": [], - "inst": { - "end_col": 64, - "end_line": 137, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 12, - "start_line": 137 - } - }, - "395": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 26, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": 197, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": 198, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": 196 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 137, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 137 - } - }, - "396": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 156, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 156 - } - }, - "398": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 - } - }, - "hints": [], - "inst": { - "end_col": 46, - "end_line": 153, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 46, - "end_line": 153, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 19, - "end_line": 157, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 9, - "start_line": 157 - }, - "While trying to retrieve the implicit argument 'builtin_ptrs' in:" - ], - "start_col": 20, - "start_line": 153 - }, - "While expanding the reference 'builtin_ptrs' in:" - ], - "start_col": 20, - "start_line": 153 - } - }, - "399": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 - } - }, - "hints": [], - "inst": { - "end_col": 68, - "end_line": 153, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 68, - "end_line": 153, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 19, - "end_line": 157, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 9, - "start_line": 157 - }, - "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" - ], - "start_col": 48, - "start_line": 153 - }, - "While expanding the reference 'self_range_check_ptr' in:" - ], - "start_col": 48, - "start_line": 153 - } - }, - "400": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 - } - }, - "hints": [], - "inst": { - "end_col": 19, - "end_line": 157, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 9, - "start_line": 157 - } - }, - "401": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 166, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 160 - }, - "n_prefix_newlines": 1 - }, - { - "location": { - "end_col": 71, - "end_line": 167, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 167 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 71, - "end_line": 167, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 167 - } - }, - "403": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 46, - "end_line": 153, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 45, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 6, - "end_line": 173, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 169 - }, - "While trying to retrieve the implicit argument 'builtin_ptrs' in:" - ], - "start_col": 19, - "start_line": 65 - }, - "While expanding the reference 'builtin_ptrs' in:" - ], - "start_col": 20, - "start_line": 153 - } - }, - "404": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 68, - "end_line": 153, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 67, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/execute_task.cairo" - }, - "parent_location": [ - { - "end_col": 6, - "end_line": 173, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 169 - }, - "While trying to retrieve the implicit argument 'self_range_check_ptr' in:" - ], - "start_col": 47, - "start_line": 65 - }, - "While expanding the reference 'self_range_check_ptr' in:" - ], - "start_col": 48, - "start_line": 153 - } - }, - "405": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 154, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 44, - "end_line": 170, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 27, - "start_line": 170 - }, - "While expanding the reference 'builtin_encodings' in:" - ], - "start_col": 5, - "start_line": 154 - } - }, - "406": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 74, - "end_line": 154, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 54, - "end_line": 171, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 32, - "start_line": 171 - }, - "While expanding the reference 'builtin_instance_sizes' in:" - ], - "start_col": 38, - "start_line": 154 - } - }, - "407": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 25, - "end_line": 167, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 34, - "end_line": 172, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 22, - "start_line": 172 - }, - "While expanding the reference 'use_poseidon' in:" - ], - "start_col": 13, - "start_line": 167 - } - }, - "408": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 173, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 169 - } - }, - "410": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 28, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 154, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 44, - "end_line": 176, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 27, - "start_line": 176 - }, - "While expanding the reference 'builtin_encodings' in:" - ], - "start_col": 5, - "start_line": 154 - } - }, - "411": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 28, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 74, - "end_line": 154, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 54, - "end_line": 177, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 32, - "start_line": 177 - }, - "While expanding the reference 'builtin_instance_sizes' in:" - ], - "start_col": 38, - "start_line": 154 - } - }, - "412": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 28, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 178, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 17, - "start_line": 178 - } - }, - "414": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 28, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 205, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 206, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 179, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 12, - "start_line": 175 - } - }, - "416": { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 29, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 207, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 208, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": 204 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 179, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "start_col": 5, - "start_line": 175 - } - }, - "417": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 30, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn.a": 209, - "starkware.cairo.common.math.assert_nn.range_check_ptr": 210 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 46, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 42 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 26, - "end_line": 47, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 47 - } - }, - "418": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 30, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn.a": 209, - "starkware.cairo.common.math.assert_nn.range_check_ptr": 211 - } - }, - "hints": [], - "inst": { - "end_col": 46, - "end_line": 48, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 49, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 49 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 16, - "start_line": 41 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 27, - "start_line": 48 - } - }, - "420": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 30, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn.a": 209, - "starkware.cairo.common.math.assert_nn.range_check_ptr": 211 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 49, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 49 - } - }, - "421": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 31, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_le.a": 212, - "starkware.cairo.common.math.assert_le.b": 213, - "starkware.cairo.common.math.assert_le.range_check_ptr": 214 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 53, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 21, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 54 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 16, - "start_line": 41 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 16, - "start_line": 53 - } - }, - "422": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 31, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_le.a": 212, - "starkware.cairo.common.math.assert_le.b": 213, - "starkware.cairo.common.math.assert_le.range_check_ptr": 214 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 15, - "start_line": 54 - } - }, - "423": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 31, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_le.a": 212, - "starkware.cairo.common.math.assert_le.b": 213, - "starkware.cairo.common.math.assert_le.range_check_ptr": 214 - } - }, - "hints": [], - "inst": { - "end_col": 21, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 54 - } - }, - "425": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 31, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_le.a": 212, - "starkware.cairo.common.math.assert_le.b": 213, - "starkware.cairo.common.math.assert_le.range_check_ptr": 215 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 55, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 55 - } - }, - "426": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 32, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn_le.a": 216, - "starkware.cairo.common.math.assert_nn_le.b": 217, - "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 218 - } - }, - "hints": [], - "inst": { - "end_col": 34, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 17, - "end_line": 71, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 71 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 16, - "start_line": 41 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 19, - "start_line": 70 - } - }, - "427": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 32, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn_le.a": 216, - "starkware.cairo.common.math.assert_nn_le.b": 217, - "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 218 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 16, - "end_line": 71, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 15, - "start_line": 71 - }, - "While expanding the reference 'a' in:" - ], - "start_col": 36, - "start_line": 70 - } - }, - "428": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 32, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn_le.a": 216, - "starkware.cairo.common.math.assert_nn_le.b": 217, - "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 218 - } - }, - "hints": [], - "inst": { - "end_col": 17, - "end_line": 71, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 71 - } - }, - "430": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 32, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn_le.a": 216, - "starkware.cairo.common.math.assert_nn_le.b": 217, - "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 219 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 16, - "end_line": 72, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 15, - "start_line": 72 - }, - "While expanding the reference 'a' in:" - ], - "start_col": 36, - "start_line": 70 - } - }, - "431": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 32, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn_le.a": 216, - "starkware.cairo.common.math.assert_nn_le.b": 217, - "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 219 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 19, - "end_line": 72, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 18, - "start_line": 72 - }, - "While expanding the reference 'b' in:" - ], - "start_col": 39, - "start_line": 70 - } - }, - "432": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 32, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn_le.a": 216, - "starkware.cairo.common.math.assert_nn_le.b": 217, - "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 219 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 72, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 72 - } - }, - "434": { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn_le" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 32, - "offset": 14 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn_le.a": 216, - "starkware.cairo.common.math.assert_nn_le.b": 217, - "starkware.cairo.common.math.assert_nn_le.range_check_ptr": 220 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 73, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "start_col": 5, - "start_line": 73 - } - }, - "435": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 - } - }, - "hints": [], - "inst": { - "end_col": 18, - "end_line": 27, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 5, - "start_line": 27 - } - }, - "437": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 59, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 5, - "start_line": 29 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 34, - "end_line": 26, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "parent_location": [ - { - "end_col": 34, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 40, - "end_line": 61, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 5, - "start_line": 61 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 19, - "start_line": 70 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 19, - "start_line": 26 - } - }, - "438": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 - } - }, - "hints": [], - "inst": { - "end_col": 16, - "end_line": 28, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "parent_location": [ - { - "end_col": 25, - "end_line": 61, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 20, - "start_line": 61 - }, - "While expanding the reference 'index' in:" - ], - "start_col": 11, - "start_line": 28 - } - }, - "439": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 61, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 29, - "start_line": 61 - } - }, - "441": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 61, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 5, - "start_line": 61 - } - }, - "443": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 20 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 35, - "start_line": 62 - } - }, - "444": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 21 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.__temp49": 228, - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 23, - "start_line": 62 - } - }, - "445": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 22 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.__temp49": 228, - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_ptr": 229, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 63, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 5, - "start_line": 63 - } - }, - "446": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 22 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.__temp49": 228, - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_ptr": 229, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 - } - }, - "hints": [], - "inst": { - "end_col": 34, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/math.cairo" - }, - "parent_location": [ - { - "end_col": 40, - "end_line": 61, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "parent_location": [ - { - "end_col": 34, - "end_line": 26, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "parent_location": [ - { - "end_col": 30, - "end_line": 64, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 5, - "start_line": 64 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 19, - "start_line": 26 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 61 - }, - "While trying to update the implicit return value 'range_check_ptr' in:" - ], - "start_col": 19, - "start_line": 70 - } - }, - "447": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 23 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.__temp49": 228, - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_ptr": 229, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "parent_location": [ - { - "end_col": 28, - "end_line": 64, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 21, - "start_line": 64 - }, - "While expanding the reference 'elm_ptr' in:" - ], - "start_col": 13, - "start_line": 62 - } - }, - "448": { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 24 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.__temp49": 228, - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_ptr": 229, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 227 - } - }, - "hints": [], - "inst": { - "end_col": 30, - "end_line": 64, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "start_col": 5, - "start_line": 64 - } - }, - "449": { - "accessible_scopes": [ - "starkware.cairo.common.hash", - "starkware.cairo.common.hash.hash2" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 34, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash.hash2.hash_ptr": 232, - "starkware.cairo.common.hash.hash2.x": 230, - "starkware.cairo.common.hash.hash2.y": 231 - } - }, - "hints": [], - "inst": { - "end_col": 19, - "end_line": 14, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" - }, - "start_col": 5, - "start_line": 14 - } - }, - "450": { - "accessible_scopes": [ - "starkware.cairo.common.hash", - "starkware.cairo.common.hash.hash2" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 34, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash.hash2.hash_ptr": 232, - "starkware.cairo.common.hash.hash2.x": 230, - "starkware.cairo.common.hash.hash2.y": 231 - } - }, - "hints": [], - "inst": { - "end_col": 19, - "end_line": 15, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" - }, - "start_col": 5, - "start_line": 15 - } - }, - "451": { - "accessible_scopes": [ - "starkware.cairo.common.hash", - "starkware.cairo.common.hash.hash2" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 34, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash.hash2.hash_ptr": 234, - "starkware.cairo.common.hash.hash2.result": 233, - "starkware.cairo.common.hash.hash2.x": 230, - "starkware.cairo.common.hash.hash2.y": 231 - } - }, - "hints": [], - "inst": { - "end_col": 47, - "end_line": 17, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" - }, - "parent_location": [ - { - "end_col": 34, - "end_line": 13, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" - }, - "parent_location": [ - { - "end_col": 28, - "end_line": 18, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" - }, - "start_col": 5, - "start_line": 18 - }, - "While trying to retrieve the implicit argument 'hash_ptr' in:" - ], - "start_col": 12, - "start_line": 13 - }, - "While expanding the reference 'hash_ptr' in:" - ], - "start_col": 20, - "start_line": 17 - } - }, - "453": { - "accessible_scopes": [ - "starkware.cairo.common.hash", - "starkware.cairo.common.hash.hash2" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 34, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.hash.hash2.hash_ptr": 234, - "starkware.cairo.common.hash.hash2.result": 233, - "starkware.cairo.common.hash.hash2.x": 230, - "starkware.cairo.common.hash.hash2.y": 231 - } - }, - "hints": [], - "inst": { - "end_col": 33, - "end_line": 16, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" - }, - "parent_location": [ - { - "end_col": 26, - "end_line": 18, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" - }, - "start_col": 20, - "start_line": 18 - }, - "While expanding the reference 'result' in:" - ], - "start_col": 18, - "start_line": 16 - } - }, - "454": { - "accessible_scopes": [ - "starkware.cairo.common.hash", - "starkware.cairo.common.hash.hash2" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 34, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.hash.hash2.hash_ptr": 234, - "starkware.cairo.common.hash.hash2.result": 233, - "starkware.cairo.common.hash.hash2.x": 230, - "starkware.cairo.common.hash.hash2.y": 231 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 18, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" - }, - "start_col": 5, - "start_line": 18 - } - }, - "455": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_init" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 35, - "offset": 0 - }, - "reference_ids": {} - }, - "hints": [], - "inst": { - "end_col": 18, - "end_line": 18, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 18 - } - }, - "457": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_init" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 35, - "offset": 2 - }, - "reference_ids": {} - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 19, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 23, - "start_line": 19 - } - }, - "459": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_init" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 35, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_init.__fp__": 235, - "starkware.cairo.common.hash_state.hash_init.hash_state": 236 - } - }, - "hints": [], - "inst": { - "end_col": 32, - "end_line": 21, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 21 - } - }, - "461": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_init" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 35, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_init.__fp__": 235, - "starkware.cairo.common.hash_state.hash_init.hash_state": 236 - } - }, - "hints": [], - "inst": { - "end_col": 27, - "end_line": 22, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 22 - } - }, - "463": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_init" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 35, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_init.__fp__": 235, - "starkware.cairo.common.hash_state.hash_init.hash_state": 236 - } - }, - "hints": [], - "inst": { - "end_col": 16, - "end_line": 19, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 21, - "end_line": 20, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 39, - "end_line": 23, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 29, - "start_line": 23 - }, - "While expanding the reference 'hash_state' in:" - ], - "start_col": 11, - "start_line": 20 - }, - "While expanding the reference '__fp__' in:" - ], - "start_col": 10, - "start_line": 19 - } - }, - "464": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_init" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 35, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_init.__fp__": 235, - "starkware.cairo.common.hash_state.hash_init.hash_state": 236 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 23, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 23 - } - }, - "465": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 36, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 - } - }, - "hints": [], - "inst": { - "end_col": 18, - "end_line": 32, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 32 - } - }, - "467": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 36, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 - } - }, - "hints": [], - "inst": { - "end_col": 40, - "end_line": 29, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 50, - "end_line": 82, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 6, - "end_line": 35, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 18, - "start_line": 33 - }, - "While trying to retrieve the implicit argument 'hash_ptr' in:" - ], - "start_col": 28, - "start_line": 82 - }, - "While expanding the reference 'hash_ptr' in:" - ], - "start_col": 18, - "start_line": 29 - } - }, - "468": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 36, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 - } - }, - "hints": [], - "inst": { - "end_col": 48, - "end_line": 30, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 26, - "end_line": 34, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 18, - "start_line": 34 - }, - "While expanding the reference 'data_ptr' in:" - ], - "start_col": 33, - "start_line": 30 - } - }, - "469": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 36, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 - } - }, - "hints": [], - "inst": { - "end_col": 61, - "end_line": 30, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 51, - "end_line": 34, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 40, - "start_line": 34 - }, - "While expanding the reference 'data_length' in:" - ], - "start_col": 50, - "start_line": 30 - } - }, - "470": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 36, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 - } - }, - "hints": [], - "inst": { - "end_col": 93, - "end_line": 34, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 66, - "start_line": 34 - } - }, - "471": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 36, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 240, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 35, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 18, - "start_line": 33 - } - }, - "473": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 37, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash": 242, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 36, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 23, - "start_line": 36 - } - }, - "475": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 37, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.__fp__": 243, - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash": 242, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, - "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 38, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 38 - } - }, - "476": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 37, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.__fp__": 243, - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash": 242, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, - "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 - } - }, - "hints": [], - "inst": { - "end_col": 59, - "end_line": 39, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 37, - "start_line": 39 - } - }, - "477": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 37, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.__fp__": 243, - "starkware.cairo.common.hash_state.hash_update.__temp50": 245, - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash": 242, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, - "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 - } - }, - "hints": [], - "inst": { - "end_col": 74, - "end_line": 39, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 39 - } - }, - "478": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 37, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.__fp__": 243, - "starkware.cairo.common.hash_state.hash_update.__temp50": 245, - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash": 242, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, - "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 - } - }, - "hints": [], - "inst": { - "end_col": 50, - "end_line": 82, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 6, - "end_line": 35, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 40, - "end_line": 29, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 49, - "end_line": 40, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 40 - }, - "While trying to retrieve the implicit argument 'hash_ptr' in:" - ], - "start_col": 18, - "start_line": 29 - }, - "While expanding the reference 'hash_ptr' in:" - ], - "start_col": 18, - "start_line": 33 - }, - "While trying to update the implicit return value 'hash_ptr' in:" - ], - "start_col": 28, - "start_line": 82 - } - }, - "479": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 37, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.__fp__": 243, - "starkware.cairo.common.hash_state.hash_update.__temp50": 245, - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash": 242, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, - "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 - } - }, - "hints": [], - "inst": { - "end_col": 16, - "end_line": 36, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 25, - "end_line": 37, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 47, - "end_line": 40, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 33, - "start_line": 40 - }, - "While expanding the reference 'new_hash_state' in:" - ], - "start_col": 11, - "start_line": 37 - }, - "While expanding the reference '__fp__' in:" - ], - "start_col": 10, - "start_line": 36 - } - }, - "480": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_update" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 37, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_update.__fp__": 243, - "starkware.cairo.common.hash_state.hash_update.__temp50": 245, - "starkware.cairo.common.hash_state.hash_update.data_length": 239, - "starkware.cairo.common.hash_state.hash_update.data_ptr": 238, - "starkware.cairo.common.hash_state.hash_update.hash": 242, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": 241, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": 237, - "starkware.cairo.common.hash_state.hash_update.new_hash_state": 244 - } - }, - "hints": [], - "inst": { - "end_col": 49, - "end_line": 40, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 40 - } - }, - "481": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_finalize" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 38, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, - "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 - } - }, - "hints": [], - "inst": { - "end_col": 42, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 34, - "end_line": 13, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash.cairo" - }, - "parent_location": [ - { - "end_col": 80, - "end_line": 71, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 18, - "start_line": 71 - }, - "While trying to retrieve the implicit argument 'hash_ptr' in:" - ], - "start_col": 12, - "start_line": 13 - }, - "While expanding the reference 'hash_ptr' in:" - ], - "start_col": 20, - "start_line": 70 - } - }, - "482": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_finalize" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 38, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, - "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 - } - }, - "hints": [], - "inst": { - "end_col": 53, - "end_line": 71, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 26, - "start_line": 71 - } - }, - "483": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_finalize" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 38, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, - "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 - } - }, - "hints": [], - "inst": { - "end_col": 79, - "end_line": 71, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 57, - "start_line": 71 - } - }, - "484": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_finalize" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 38, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 247, - "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 - } - }, - "hints": [], - "inst": { - "end_col": 80, - "end_line": 71, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 18, - "start_line": 71 - } - }, - "486": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_finalize" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 38, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_finalize.hash": 249, - "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": 248, - "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": 246 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 72, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 72 - } - }, - "487": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 85, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 85 - } - }, - "489": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 - } - }, - "hints": [], - "inst": { - "end_col": 50, - "end_line": 82, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 50, - "end_line": 82, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 36, - "end_line": 86, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 9, - "start_line": 86 - }, - "While trying to retrieve the implicit argument 'hash_ptr' in:" - ], - "start_col": 28, - "start_line": 82 - }, - "While expanding the reference 'hash_ptr' in:" - ], - "start_col": 28, - "start_line": 82 - } - }, - "490": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 - } - }, - "hints": [], - "inst": { - "end_col": 59, - "end_line": 83, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 34, - "end_line": 86, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 22, - "start_line": 86 - }, - "While expanding the reference 'initial_hash' in:" - ], - "start_col": 41, - "start_line": 83 - } - }, - "491": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 86, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 9, - "start_line": 86 - } - }, - "492": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 - } - }, - "hints": [], - "inst": { - "end_col": 18, - "end_line": 90, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 90 - } - }, - "494": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 - } - }, - "hints": [], - "inst": { - "end_col": 60, - "end_line": 91, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 34, - "start_line": 91 - } - }, - "496": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 - } - }, - "hints": [], - "inst": { - "end_col": 61, - "end_line": 91, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 91 - } - }, - "497": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 - } - }, - "hints": [], - "inst": { - "end_col": 43, - "end_line": 100, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 100 - } - }, - "498": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 - } - }, - "hints": [], - "inst": { - "end_col": 43, - "end_line": 101, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 101 - } - }, - "499": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252 - } - }, - "hints": [], - "inst": { - "end_col": 47, - "end_line": 102, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 102 - } - }, - "500": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, - "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 - } - }, - "hints": [], - "inst": { - "end_col": 72, - "end_line": 107, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 36, - "start_line": 107 - } - }, - "501": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, - "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, - "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 - } - }, - "hints": [], - "inst": { - "end_col": 50, - "end_line": 110, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 110 - } - }, - "502": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, - "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, - "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 - } - }, - "hints": [], - "inst": { - "end_col": 59, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 37, - "start_line": 111 - } - }, - "503": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, - "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, - "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 - } - }, - "hints": [], - "inst": { - "end_col": 60, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 111 - } - }, - "504": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, - "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, - "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, - "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 - } - }, - "hints": [], - "inst": { - "end_col": 58, - "end_line": 115, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 115 - } - }, - "506": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, - "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, - "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, - "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 - } - }, - "hints": [], - "inst": { - "end_col": 73, - "end_line": 116, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 116 - } - }, - "508": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, - "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, - "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, - "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 - } - }, - "hints": [], - "inst": { - "end_col": 61, - "end_line": 117, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 117 - } - }, - "509": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 253, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, - "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, - "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, - "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 - } - }, - "hints": [], - "inst": { - "end_col": 47, - "end_line": 120, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 120 - } - }, - "511": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts_no_padding" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 39, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": 254, - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": 259, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": 255, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": 251, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": 250, - "starkware.cairo.common.hash_state.hash_felts_no_padding.final_locals": 261, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": 256, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": 262, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": 252, - "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": 258, - "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": 260, - "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": 257 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 125, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 125 - } - }, - "512": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 40, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts.data": 263, - "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, - "starkware.cairo.common.hash_state.hash_felts.length": 264 - } - }, - "hints": [], - "inst": { - "end_col": 51, - "end_line": 137, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 40, - "start_line": 137 - } - }, - "514": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 40, - "offset": 7 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts.data": 263, - "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, - "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, - "starkware.cairo.common.hash_state.hash_felts.length": 264 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 136, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 40, - "end_line": 29, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 6, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 28, - "start_line": 138 - }, - "While trying to retrieve the implicit argument 'hash_ptr' in:" - ], - "start_col": 18, - "start_line": 29 - }, - "While expanding the reference 'hash_ptr' in:" - ], - "start_col": 17, - "start_line": 136 - } - }, - "515": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 40, - "offset": 8 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts.data": 263, - "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, - "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, - "starkware.cairo.common.hash_state.hash_felts.length": 264 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 137, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 38, - "end_line": 139, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 24, - "start_line": 139 - }, - "While expanding the reference 'hash_state_ptr' in:" - ], - "start_col": 10, - "start_line": 137 - } - }, - "516": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 40, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts.data": 263, - "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, - "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, - "starkware.cairo.common.hash_state.hash_felts.length": 264 - } - }, - "hints": [], - "inst": { - "end_col": 52, - "end_line": 136, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 53, - "end_line": 139, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 49, - "start_line": 139 - }, - "While expanding the reference 'data' in:" - ], - "start_col": 41, - "start_line": 136 - } - }, - "517": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 40, - "offset": 10 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts.data": 263, - "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, - "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, - "starkware.cairo.common.hash_state.hash_felts.length": 264 - } - }, - "hints": [], - "inst": { - "end_col": 66, - "end_line": 136, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "parent_location": [ - { - "end_col": 73, - "end_line": 139, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 67, - "start_line": 139 - }, - "While expanding the reference 'length' in:" - ], - "start_col": 54, - "start_line": 136 - } - }, - "518": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 40, - "offset": 11 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts.data": 263, - "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 265, - "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 266, - "starkware.cairo.common.hash_state.hash_felts.length": 264 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 140, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 28, - "start_line": 138 - } - }, - "520": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 41, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts.data": 263, - "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 267, - "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 268, - "starkware.cairo.common.hash_state.hash_felts.length": 264 - } - }, - "hints": [], - "inst": { - "end_col": 56, - "end_line": 141, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 12, - "start_line": 141 - } - }, - "522": { - "accessible_scopes": [ - "starkware.cairo.common.hash_state", - "starkware.cairo.common.hash_state.hash_felts" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 41, - "offset": 9 - }, - "reference_ids": { - "starkware.cairo.common.hash_state.hash_felts.data": 263, - "starkware.cairo.common.hash_state.hash_felts.hash_ptr": 269, - "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": 268, - "starkware.cairo.common.hash_state.hash_felts.length": 264 - } - }, - "hints": [], - "inst": { - "end_col": 57, - "end_line": 141, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/hash_state.cairo" - }, - "start_col": 5, - "start_line": 141 - } - }, - "523": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 8, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 5, - "start_line": 8 - } - }, - "525": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [], - "inst": { - "end_col": 19, - "end_line": 9, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 9, - "start_line": 9 - } - }, - "526": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [ - { - "location": { - "end_col": 41, - "end_line": 12, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 5, - "start_line": 12 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 23, - "end_line": 2, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "parent_location": [ - { - "end_col": 38, - "end_line": 13, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 35, - "start_line": 13 - }, - "While expanding the reference 'dst' in:" - ], - "start_col": 13, - "start_line": 2 - } - }, - "527": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [], - "inst": { - "end_col": 35, - "end_line": 2, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "parent_location": [ - { - "end_col": 47, - "end_line": 13, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 44, - "start_line": 13 - }, - "While expanding the reference 'src' in:" - ], - "start_col": 25, - "start_line": 2 - } - }, - "528": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.frame": 274, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 17, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 26, - "start_line": 17 - } - }, - "529": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.__temp53": 275, - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.frame": 274, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 17, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 5, - "start_line": 17 - } - }, - "530": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.__temp53": 275, - "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.frame": 274, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.next_frame": 277, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 22, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 5, - "start_line": 22 - } - }, - "532": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 4 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.__temp53": 275, - "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.frame": 274, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.next_frame": 277, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 23, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 5, - "start_line": 23 - } - }, - "534": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.__temp53": 275, - "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.frame": 274, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.next_frame": 277, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 27, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 5, - "start_line": 24 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 44, - "end_line": 29, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 5, - "start_line": 29 - } - }, - "536": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.__temp53": 275, - "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.frame": 274, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.next_frame": 277, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [], - "inst": { - "end_col": 55, - "end_line": 31, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 5, - "start_line": 31 - } - }, - "537": { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.__temp53": 275, - "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.frame": 274, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.next_frame": 277, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - }, - "hints": [ - { - "location": { - "end_col": 26, - "end_line": 33, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 5, - "start_line": 33 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 15, - "end_line": 34, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/memcpy.cairo" - }, - "start_col": 5, - "start_line": 34 - } - }, - "538": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 41, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 41 - } - }, - "540": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 11 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 54, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 44 - }, - "n_prefix_newlines": 1 - }, - { - "location": { - "end_col": 53, - "end_line": 61, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 61 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 41, - "end_line": 43, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 77, - "end_line": 57, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 66, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 38, - "start_line": 62 - }, - "While expanding the reference 'simple_bootloader_output_ptr' in:" - ], - "start_col": 47, - "start_line": 57 - }, - "While expanding the reference 'simple_bootloader_output_start' in:" - ], - "start_col": 11, - "start_line": 43 - } - }, - "541": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 12 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 32, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 15, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 62 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 15 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 32 - } - }, - "542": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 13 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 33, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 16, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 62 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 16 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 33 - } - }, - "543": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 14 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 14, - "end_line": 34, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 14, - "end_line": 17, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 62 - }, - "While trying to retrieve the implicit argument 'ecdsa_ptr' in:" - ], - "start_col": 5, - "start_line": 17 - }, - "While expanding the reference 'ecdsa_ptr' in:" - ], - "start_col": 5, - "start_line": 34 - } - }, - "544": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 15 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 16, - "end_line": 35, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 16, - "end_line": 18, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 62 - }, - "While trying to retrieve the implicit argument 'bitwise_ptr' in:" - ], - "start_col": 5, - "start_line": 18 - }, - "While expanding the reference 'bitwise_ptr' in:" - ], - "start_col": 5, - "start_line": 35 - } - }, - "545": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 16 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 14, - "end_line": 36, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 14, - "end_line": 19, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 62 - }, - "While trying to retrieve the implicit argument 'ec_op_ptr' in:" - ], - "start_col": 5, - "start_line": 19 - }, - "While expanding the reference 'ec_op_ptr' in:" - ], - "start_col": 5, - "start_line": 36 - } - }, - "546": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 17 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 37, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 20, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 62 - }, - "While trying to retrieve the implicit argument 'keccak_ptr' in:" - ], - "start_col": 5, - "start_line": 20 - }, - "While expanding the reference 'keccak_ptr' in:" - ], - "start_col": 5, - "start_line": 37 - } - }, - "547": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 18 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 35, - "end_line": 38, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 35, - "end_line": 21, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 62 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 21 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 38 - } - }, - "548": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 19 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 22, - "end_line": 39, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 22, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 62 - }, - "While trying to retrieve the implicit argument 'range_check96_ptr' in:" - ], - "start_col": 5, - "start_line": 22 - }, - "While expanding the reference 'range_check96_ptr' in:" - ], - "start_col": 5, - "start_line": 39 - } - }, - "549": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 20 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 69, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 62 - } - }, - "551": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 293, - "__main__.main.ec_op_ptr": 294, - "__main__.main.ecdsa_ptr": 292, - "__main__.main.keccak_ptr": 295, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 296, - "__main__.main.range_check96_ptr": 297, - "__main__.main.range_check_ptr": 291, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 45, - "end_line": 63, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 63 - } - }, - "552": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 293, - "__main__.main.ec_op_ptr": 294, - "__main__.main.ecdsa_ptr": 292, - "__main__.main.keccak_ptr": 295, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 296, - "__main__.main.range_check96_ptr": 297, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 33, - "end_line": 64, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 64 - } - }, - "553": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 293, - "__main__.main.ec_op_ptr": 294, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 295, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 296, - "__main__.main.range_check96_ptr": 297, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 65 - } - }, - "554": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.ec_op_ptr": 294, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 295, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 296, - "__main__.main.range_check96_ptr": 297, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 33, - "end_line": 66, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 66 - } - }, - "555": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 295, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 296, - "__main__.main.range_check96_ptr": 297, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 35, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 67 - } - }, - "556": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 296, - "__main__.main.range_check96_ptr": 297, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 57, - "end_line": 68, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 68 - } - }, - "557": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 297, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 49, - "end_line": 69, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 69 - } - }, - "558": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 78, - "end_line": 70, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 70 - } - }, - "559": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 75, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 72 - }, - "n_prefix_newlines": 1 - }, - { - "location": { - "end_col": 7, - "end_line": 89, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 78 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 22, - "end_line": 31, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 51, - "end_line": 219, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 92, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 92 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 34, - "start_line": 219 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 31 - } - }, - "560": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 1 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 15, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/simple_bootloader/run_simple_bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 62, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 79, - "end_line": 219, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 92, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 92 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 53, - "start_line": 219 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 62 - }, - "While trying to update the implicit return value 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 15 - } - }, - "561": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 2 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 77, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 68, - "end_line": 92, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 51, - "start_line": 92 - }, - "While expanding the reference 'bootloader_config' in:" - ], - "start_col": 11, - "start_line": 77 - } - }, - "562": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 3 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 69, - "end_line": 92, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 92 - } - }, - "564": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_ptr": 307, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 56, - "end_line": 95, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 95 - } - }, - "565": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 314, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 313, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [ - { - "location": { - "end_col": 40, - "end_line": 97, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 97 - }, - "n_prefix_newlines": 0 - }, - { - "location": { - "end_col": 59, - "end_line": 107, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 107 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 36, - "end_line": 96, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 169, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 109 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 169 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 22, - "start_line": 96 - } - }, - "567": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 1 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 314, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 313, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 79, - "end_line": 219, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 69, - "end_line": 92, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 170, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 109 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 170 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 92 - }, - "While trying to update the implicit return value 'pedersen_ptr' in:" - ], - "start_col": 53, - "start_line": 219 - } - }, - "568": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 2 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 314, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 313, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 23, - "end_line": 68, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 35, - "end_line": 171, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 109 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 171 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 11, - "start_line": 68 - } - }, - "569": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 3 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 314, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 313, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 26, - "end_line": 63, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 172, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 109 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 172 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 11, - "start_line": 63 - } - }, - "570": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 4 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 314, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 313, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 32, - "end_line": 106, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 24, - "end_line": 173, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 109 - }, - "While trying to retrieve the implicit argument 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 173 - }, - "While expanding the reference 'n_total_tasks' in:" - ], - "start_col": 31, - "start_line": 106 - } - }, - "572": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 5 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 314, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 313, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 72, - "end_line": 103, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 65, - "end_line": 109, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 37, - "start_line": 109 - }, - "While expanding the reference 'simple_bootloader_output_ptr' in:" - ], - "start_col": 40, - "start_line": 103 - } - }, - "574": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 6 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 314, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 313, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 77, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 48, - "end_line": 110, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 31, - "start_line": 110 - }, - "While expanding the reference 'bootloader_config' in:" - ], - "start_col": 11, - "start_line": 77 - } - }, - "575": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 7 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 314, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 313, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 52, - "end_line": 102, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 71, - "end_line": 110, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 61, - "start_line": 110 - }, - "While expanding the reference 'n_subtasks' in:" - ], - "start_col": 22, - "start_line": 102 - } - }, - "576": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 8 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 314, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 313, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 10, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 109 - } - }, - "578": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 59, - "end_line": 116, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 116 - } - }, - "579": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 55, - "end_line": 119, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 119 - } - }, - "580": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 149, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 121 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 22, - "end_line": 169, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 31, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 150, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 150 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 31 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 9, - "start_line": 109 - }, - "While trying to update the implicit return value 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 169 - } - }, - "581": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 1 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 170, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 32, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 150, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 150 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 32 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 9, - "start_line": 109 - }, - "While trying to update the implicit return value 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 170 - } - }, - "582": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 2 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 172, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 33, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 150, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 150 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 33 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 9, - "start_line": 109 - }, - "While trying to update the implicit return value 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 172 - } - }, - "583": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 3 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 64, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 14, - "end_line": 34, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 150, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 150 - }, - "While trying to retrieve the implicit argument 'ecdsa_ptr' in:" - ], - "start_col": 5, - "start_line": 34 - }, - "While expanding the reference 'ecdsa_ptr' in:" - ], - "start_col": 11, - "start_line": 64 - } - }, - "584": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 4 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 22, - "end_line": 65, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 16, - "end_line": 35, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 150, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 150 - }, - "While trying to retrieve the implicit argument 'bitwise_ptr' in:" - ], - "start_col": 5, - "start_line": 35 - }, - "While expanding the reference 'bitwise_ptr' in:" - ], - "start_col": 11, - "start_line": 65 - } - }, - "585": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 5 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 66, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 14, - "end_line": 36, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 150, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 150 - }, - "While trying to retrieve the implicit argument 'ec_op_ptr' in:" - ], - "start_col": 5, - "start_line": 36 - }, - "While expanding the reference 'ec_op_ptr' in:" - ], - "start_col": 11, - "start_line": 66 - } - }, - "586": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 6 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 21, - "end_line": 67, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 37, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 150, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 150 - }, - "While trying to retrieve the implicit argument 'keccak_ptr' in:" - ], - "start_col": 5, - "start_line": 37 - }, - "While expanding the reference 'keccak_ptr' in:" - ], - "start_col": 11, - "start_line": 67 - } - }, - "587": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 7 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 35, - "end_line": 171, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 111, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 35, - "end_line": 38, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 150, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 150 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 38 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 9, - "start_line": 109 - }, - "While trying to update the implicit return value 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 171 - } - }, - "588": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 8 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 28, - "end_line": 69, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 39, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 150, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 150 - }, - "While trying to retrieve the implicit argument 'range_check96_ptr' in:" - ], - "start_col": 5, - "start_line": 39 - }, - "While expanding the reference 'range_check96_ptr' in:" - ], - "start_col": 11, - "start_line": 69 - } - }, - "589": { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 9 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 150, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 150 - } - }, - "590": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 176, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 176 - } - }, - "592": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 22, - "end_line": 169, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 169, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 19, - "end_line": 177, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 177 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 169 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 169 - } - }, - "593": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 1 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 170, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 170, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 19, - "end_line": 177, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 177 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 170 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 170 - } - }, - "594": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 2 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 35, - "end_line": 171, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 35, - "end_line": 171, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 19, - "end_line": 177, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 177 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 171 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 171 - } - }, - "595": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 3 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 172, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 172, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 19, - "end_line": 177, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 177 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 172 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 172 - } - }, - "596": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 4 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 173, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 24, - "end_line": 173, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 19, - "end_line": 177, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 177 - }, - "While trying to retrieve the implicit argument 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 173 - }, - "While expanding the reference 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 173 - } - }, - "597": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 5 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 27, - "end_line": 174, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 27, - "end_line": 174, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 19, - "end_line": 177, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 177 - }, - "While trying to retrieve the implicit argument 'subtasks_output' in:" - ], - "start_col": 5, - "start_line": 174 - }, - "While expanding the reference 'subtasks_output' in:" - ], - "start_col": 5, - "start_line": 174 - } - }, - "598": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 6 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 19, - "end_line": 177, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 177 - } - }, - "599": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 180, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 180 - } - }, - "601": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 189, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 182 - }, - "n_prefix_newlines": 1 - }, - { - "location": { - "end_col": 7, - "end_line": 196, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 191 - }, - "n_prefix_newlines": 1 - }, - { - "location": { - "end_col": 66, - "end_line": 198, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 198 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 66, - "end_line": 198, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 198 - } - }, - "603": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 1 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 198, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 198 - } - }, - "605": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 1 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [ - { - "location": { - "end_col": 70, - "end_line": 203, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 203 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 22, - "end_line": 169, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 260, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 206, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 204 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 260 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 169 - } - }, - "606": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 2 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 170, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 261, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 206, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 204 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 261 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 170 - } - }, - "607": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 3 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 35, - "end_line": 171, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 35, - "end_line": 262, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 206, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 204 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 262 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 171 - } - }, - "608": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 4 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 172, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 263, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 206, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 204 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 263 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 172 - } - }, - "609": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 5 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 173, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 24, - "end_line": 264, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 206, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 204 - }, - "While trying to retrieve the implicit argument 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 264 - }, - "While expanding the reference 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 173 - } - }, - "610": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 6 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 27, - "end_line": 174, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 65, - "end_line": 204, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 50, - "start_line": 204 - }, - "While expanding the reference 'subtasks_output' in:" - ], - "start_col": 5, - "start_line": 174 - } - }, - "611": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 7 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 175, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 48, - "end_line": 205, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 31, - "start_line": 205 - }, - "While expanding the reference 'bootloader_config' in:" - ], - "start_col": 3, - "start_line": 175 - } - }, - "612": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 8 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 10, - "end_line": 206, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 204 - } - }, - "614": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 48, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 335, - "__main__.parse_tasks.output_ptr": 331, - "__main__.parse_tasks.pedersen_ptr": 332, - "__main__.parse_tasks.poseidon_ptr": 333, - "__main__.parse_tasks.range_check_ptr": 334, - "__main__.parse_tasks.subtasks_output": 336 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 198, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 198 - } - }, - "616": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 1 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 22, - "end_line": 169, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 329, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 99, - "end_line": 200, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 200 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 329 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 169 - } - }, - "617": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 2 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 170, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 330, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 99, - "end_line": 200, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 200 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 330 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 170 - } - }, - "618": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 3 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 35, - "end_line": 171, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 35, - "end_line": 331, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 99, - "end_line": 200, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 200 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 331 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 171 - } - }, - "619": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 4 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 172, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 332, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 99, - "end_line": 200, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 200 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 332 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 172 - } - }, - "620": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 5 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 173, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 24, - "end_line": 333, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 99, - "end_line": 200, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 200 - }, - "While trying to retrieve the implicit argument 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 333 - }, - "While expanding the reference 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 173 - } - }, - "621": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 6 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 27, - "end_line": 174, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 61, - "end_line": 200, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 46, - "start_line": 200 - }, - "While expanding the reference 'subtasks_output' in:" - ], - "start_col": 5, - "start_line": 174 - } - }, - "622": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 7 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 175, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 98, - "end_line": 200, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 81, - "start_line": 200 - }, - "While expanding the reference 'bootloader_config' in:" - ], - "start_col": 3, - "start_line": 175 - } - }, - "623": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 8 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - }, - "hints": [], - "inst": { - "end_col": 99, - "end_line": 200, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 200 - } - }, - "625": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 50, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 347, - "__main__.parse_tasks.output_ptr": 343, - "__main__.parse_tasks.pedersen_ptr": 344, - "__main__.parse_tasks.poseidon_ptr": 345, - "__main__.parse_tasks.range_check_ptr": 346, - "__main__.parse_tasks.subtasks_output": 348 - } - }, - "hints": [ - { - "location": { - "end_col": 26, - "end_line": 209, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 209 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 39, - "end_line": 175, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 59, - "end_line": 212, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 42, - "start_line": 212 - }, - "While expanding the reference 'bootloader_config' in:" - ], - "start_col": 3, - "start_line": 175 - } - }, - "626": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 50, - "offset": 1 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 347, - "__main__.parse_tasks.output_ptr": 343, - "__main__.parse_tasks.pedersen_ptr": 344, - "__main__.parse_tasks.poseidon_ptr": 345, - "__main__.parse_tasks.range_check_ptr": 346, - "__main__.parse_tasks.subtasks_output": 348 - } - }, - "hints": [], - "inst": { - "end_col": 86, - "end_line": 212, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 72, - "start_line": 212 - } - }, - "628": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 50, - "offset": 2 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 347, - "__main__.parse_tasks.output_ptr": 343, - "__main__.parse_tasks.pedersen_ptr": 344, - "__main__.parse_tasks.poseidon_ptr": 345, - "__main__.parse_tasks.range_check_ptr": 346, - "__main__.parse_tasks.subtasks_output": 348 - } - }, - "hints": [], - "inst": { - "end_col": 87, - "end_line": 212, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 12, - "start_line": 212 - } - }, - "630": { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 51, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 353, - "__main__.parse_tasks.output_ptr": 349, - "__main__.parse_tasks.pedersen_ptr": 350, - "__main__.parse_tasks.poseidon_ptr": 351, - "__main__.parse_tasks.range_check_ptr": 352, - "__main__.parse_tasks.subtasks_output": 354 - } - }, - "hints": [], - "inst": { - "end_col": 88, - "end_line": 212, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 212 - } - }, - "631": { - "accessible_scopes": [ - "__main__", - "__main__.serialize_bootloader_config" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 52, - "offset": 0 - }, - "reference_ids": { - "__main__.serialize_bootloader_config.bootloader_config": 355, - "__main__.serialize_bootloader_config.output_ptr": 356, - "__main__.serialize_bootloader_config.pedersen_ptr": 357 - } - }, - "hints": [], - "inst": { - "end_col": 75, - "end_line": 222, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 27, - "start_line": 222 - } - }, - "632": { - "accessible_scopes": [ - "__main__", - "__main__.serialize_bootloader_config" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 52, - "offset": 1 - }, - "reference_ids": { - "__main__.serialize_bootloader_config.__temp55": 358, - "__main__.serialize_bootloader_config.bootloader_config": 355, - "__main__.serialize_bootloader_config.output_ptr": 356, - "__main__.serialize_bootloader_config.pedersen_ptr": 357 - } - }, - "hints": [], - "inst": { - "end_col": 76, - "end_line": 222, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 222 - } - }, - "633": { - "accessible_scopes": [ - "__main__", - "__main__.serialize_bootloader_config" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 52, - "offset": 1 - }, - "reference_ids": { - "__main__.serialize_bootloader_config.__temp55": 358, - "__main__.serialize_bootloader_config.bootloader_config": 355, - "__main__.serialize_bootloader_config.output_ptr": 356, - "__main__.serialize_bootloader_config.pedersen_ptr": 357 - } - }, - "hints": [], - "inst": { - "end_col": 79, - "end_line": 219, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 76, - "end_line": 225, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 64, - "start_line": 225 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 53, - "start_line": 219 - } - }, - "634": { - "accessible_scopes": [ - "__main__", - "__main__.serialize_bootloader_config" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 52, - "offset": 2 - }, - "reference_ids": { - "__main__.serialize_bootloader_config.__temp55": 358, - "__main__.serialize_bootloader_config.bootloader_config": 355, - "__main__.serialize_bootloader_config.output_ptr": 356, - "__main__.serialize_bootloader_config.pedersen_ptr": 357 - } - }, - "hints": [], - "inst": { - "end_col": 71, - "end_line": 226, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 14, - "start_line": 226 - } - }, - "635": { - "accessible_scopes": [ - "__main__", - "__main__.serialize_bootloader_config" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 52, - "offset": 3 - }, - "reference_ids": { - "__main__.serialize_bootloader_config.__temp55": 358, - "__main__.serialize_bootloader_config.bootloader_config": 355, - "__main__.serialize_bootloader_config.output_ptr": 356, - "__main__.serialize_bootloader_config.pedersen_ptr": 357 - } - }, - "hints": [], - "inst": { - "end_col": 77, - "end_line": 227, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 16, - "start_line": 227 - } - }, - "636": { - "accessible_scopes": [ - "__main__", - "__main__.serialize_bootloader_config" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 52, - "offset": 4 - }, - "reference_ids": { - "__main__.serialize_bootloader_config.__temp55": 358, - "__main__.serialize_bootloader_config.bootloader_config": 355, - "__main__.serialize_bootloader_config.output_ptr": 356, - "__main__.serialize_bootloader_config.pedersen_ptr": 357 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 228, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 44, - "start_line": 225 - } - }, - "638": { - "accessible_scopes": [ - "__main__", - "__main__.serialize_bootloader_config" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 53, - "offset": 0 - }, - "reference_ids": { - "__main__.serialize_bootloader_config.__temp55": 358, - "__main__.serialize_bootloader_config.bootloader_config": 355, - "__main__.serialize_bootloader_config.output_ptr": 356, - "__main__.serialize_bootloader_config.pedersen_ptr": 359, - "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 - } - }, - "hints": [], - "inst": { - "end_col": 62, - "end_line": 230, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 230 - } - }, - "639": { - "accessible_scopes": [ - "__main__", - "__main__.serialize_bootloader_config" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 53, - "offset": 0 - }, - "reference_ids": { - "__main__.serialize_bootloader_config.__temp55": 358, - "__main__.serialize_bootloader_config.bootloader_config": 355, - "__main__.serialize_bootloader_config.output_ptr": 361, - "__main__.serialize_bootloader_config.pedersen_ptr": 359, - "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 - } - }, - "hints": [], - "inst": { - "end_col": 36, - "end_line": 231, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 51, - "end_line": 219, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 232, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 232 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 34, - "start_line": 219 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 22, - "start_line": 231 - } - }, - "641": { - "accessible_scopes": [ - "__main__", - "__main__.serialize_bootloader_config" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 53, - "offset": 1 - }, - "reference_ids": { - "__main__.serialize_bootloader_config.__temp55": 358, - "__main__.serialize_bootloader_config.bootloader_config": 355, - "__main__.serialize_bootloader_config.output_ptr": 361, - "__main__.serialize_bootloader_config.pedersen_ptr": 359, - "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 - } - }, - "hints": [], - "inst": { - "end_col": 76, - "end_line": 225, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 79, - "end_line": 219, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 232, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 232 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 53, - "start_line": 219 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 64, - "start_line": 225 - } - }, - "642": { - "accessible_scopes": [ - "__main__", - "__main__.serialize_bootloader_config" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 53, - "offset": 2 - }, - "reference_ids": { - "__main__.serialize_bootloader_config.__temp55": 358, - "__main__.serialize_bootloader_config.bootloader_config": 355, - "__main__.serialize_bootloader_config.output_ptr": 361, - "__main__.serialize_bootloader_config.pedersen_ptr": 359, - "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": 360 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 232, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 232 - } - }, - "643": { - "accessible_scopes": [ - "__main__", - "__main__.parse_task_header" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 54, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_task_header.task_header": 363, - "__main__.parse_task_header.task_output": 364 - } - }, - "hints": [], - "inst": { - "end_col": 58, - "end_line": 242, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 42, - "end_line": 240, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 38, - "end_line": 243, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 243 - }, - "While trying to retrieve the implicit argument 'task_output' in:" - ], - "start_col": 24, - "start_line": 240 - }, - "While expanding the reference 'task_output' in:" - ], - "start_col": 23, - "start_line": 242 - } - }, - "645": { - "accessible_scopes": [ - "__main__", - "__main__.parse_task_header" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 54, - "offset": 1 - }, - "reference_ids": { - "__main__.parse_task_header.task_header": 363, - "__main__.parse_task_header.task_output": 364 - } - }, - "hints": [], - "inst": { - "end_col": 59, - "end_line": 241, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 36, - "end_line": 243, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 25, - "start_line": 243 - }, - "While expanding the reference 'task_header' in:" - ], - "start_col": 23, - "start_line": 241 - } - }, - "646": { - "accessible_scopes": [ - "__main__", - "__main__.parse_task_header" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 54, - "offset": 2 - }, - "reference_ids": { - "__main__.parse_task_header.task_header": 363, - "__main__.parse_task_header.task_output": 364 - } - }, - "hints": [], - "inst": { - "end_col": 38, - "end_line": 243, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 243 - } - }, - "647": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 55, - "offset": 0 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 368, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.task_output": 371 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 267, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 267 - } - }, - "649": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 55, - "offset": 4 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 368, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.task_output": 371 - } - }, - "hints": [ - { - "location": { - "end_col": 7, - "end_line": 276, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 272 - }, - "n_prefix_newlines": 1 - } - ], - "inst": { - "end_col": 35, - "end_line": 262, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 55, - "end_line": 28, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 6, - "end_line": 281, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 40, - "start_line": 279 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 25, - "start_line": 28 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 262 - } - }, - "650": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 55, - "offset": 5 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 368, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.task_output": 371 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 271, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 37, - "end_line": 280, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 11, - "start_line": 280 - }, - "While expanding the reference 'nested_subtasks_output_len' in:" - ], - "start_col": 11, - "start_line": 271 - } - }, - "651": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 55, - "offset": 6 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 368, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.task_output": 371 - } - }, - "hints": [], - "inst": { - "end_col": 33, - "end_line": 270, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 70, - "end_line": 280, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 48, - "start_line": 280 - }, - "While expanding the reference 'nested_subtasks_output' in:" - ], - "start_col": 11, - "start_line": 270 - } - }, - "652": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 55, - "offset": 7 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 368, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.task_output": 371 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 281, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 40, - "start_line": 279 - } - }, - "654": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 0 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_output": 371 - } - }, - "hints": [], - "inst": { - "end_col": 23, - "end_line": 265, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 42, - "end_line": 240, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 63, - "end_line": 284, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 44, - "start_line": 284 - }, - "While trying to retrieve the implicit argument 'task_output' in:" - ], - "start_col": 24, - "start_line": 240 - }, - "While expanding the reference 'task_output' in:" - ], - "start_col": 5, - "start_line": 265 - } - }, - "655": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 1 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_output": 371 - } - }, - "hints": [], - "inst": { - "end_col": 63, - "end_line": 284, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 44, - "start_line": 284 - } - }, - "657": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 5 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 79, - "end_line": 285, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 31, - "start_line": 285 - } - }, - "659": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 6 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 80, - "end_line": 285, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 285 - } - }, - "660": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 6 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 263, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 34, - "end_line": 26, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "parent_location": [ - { - "end_col": 6, - "end_line": 293, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 288 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 19, - "start_line": 26 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 263 - } - }, - "661": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 7 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 76, - "end_line": 289, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 19, - "start_line": 289 - } - }, - "662": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 8 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 19, - "end_line": 290, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 18, - "start_line": 290 - } - }, - "664": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 9 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 77, - "end_line": 291, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 16, - "start_line": 291 - } - }, - "665": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 10 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 37, - "end_line": 292, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 13, - "start_line": 292 - } - }, - "666": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 11 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 6, - "end_line": 293, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 288 - } - }, - "668": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 37 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 70, - "end_line": 297, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 22, - "start_line": 297 - } - }, - "669": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 38 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 299, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 296 - } - }, - "670": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 38 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 7, - "end_line": 299, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 296 - } - }, - "671": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 38 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 376 - } - }, - "hints": [], - "inst": { - "end_col": 71, - "end_line": 300, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 300 - } - }, - "673": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 38 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 72, - "end_line": 303, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 303 - } - }, - "674": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 38 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [ - { - "location": { - "end_col": 50, - "end_line": 306, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 306 - }, - "n_prefix_newlines": 0 - } - ], - "inst": { - "end_col": 22, - "end_line": 260, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 169, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 308 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 169 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 260 - } - }, - "675": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 39 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 261, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 170, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 308 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 170 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 261 - } - }, - "676": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 40 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 55, - "end_line": 28, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/builtin_poseidon/poseidon.cairo" - }, - "parent_location": [ - { - "end_col": 6, - "end_line": 281, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 35, - "end_line": 171, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 308 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 171 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 40, - "start_line": 279 - }, - "While trying to update the implicit return value 'poseidon_ptr' in:" - ], - "start_col": 25, - "start_line": 28 - } - }, - "677": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 41 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 34, - "end_line": 26, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/common/find_element.cairo" - }, - "parent_location": [ - { - "end_col": 6, - "end_line": 293, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 172, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 308 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 172 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 288 - }, - "While trying to update the implicit return value 'range_check_ptr' in:" - ], - "start_col": 19, - "start_line": 26 - } - }, - "678": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 42 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 264, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 24, - "end_line": 173, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 308 - }, - "While trying to retrieve the implicit argument 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 173 - }, - "While expanding the reference 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 264 - } - }, - "679": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 43 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 60, - "end_line": 305, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 59, - "end_line": 308, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 37, - "start_line": 308 - }, - "While expanding the reference 'nested_subtasks_output' in:" - ], - "start_col": 34, - "start_line": 305 - } - }, - "681": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 44 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 39, - "end_line": 266, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 48, - "end_line": 309, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 31, - "start_line": 309 - }, - "While expanding the reference 'bootloader_config' in:" - ], - "start_col": 3, - "start_line": 266 - } - }, - "682": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 45 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 46, - "end_line": 304, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 71, - "end_line": 309, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 61, - "start_line": 309 - }, - "While expanding the reference 'n_subtasks' in:" - ], - "start_col": 22, - "start_line": 304 - } - }, - "683": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 46 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 9, - "start_line": 308 - } - }, - "685": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 57, - "offset": 0 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 389, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 385, - "__main__.unpack_composite_packed_task.pedersen_ptr": 386, - "__main__.unpack_composite_packed_task.poseidon_ptr": 387, - "__main__.unpack_composite_packed_task.range_check_ptr": 388, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 95, - "end_line": 314, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 314 - } - }, - "686": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 57, - "offset": 0 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 389, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 385, - "__main__.unpack_composite_packed_task.pedersen_ptr": 386, - "__main__.unpack_composite_packed_task.poseidon_ptr": 387, - "__main__.unpack_composite_packed_task.range_check_ptr": 388, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 22, - "end_line": 169, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 260, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 315, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 315 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 260 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 9, - "start_line": 308 - }, - "While trying to update the implicit return value 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 169 - } - }, - "687": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 57, - "offset": 1 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 389, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 385, - "__main__.unpack_composite_packed_task.pedersen_ptr": 386, - "__main__.unpack_composite_packed_task.poseidon_ptr": 387, - "__main__.unpack_composite_packed_task.range_check_ptr": 388, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 170, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 261, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 315, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 315 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 261 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 9, - "start_line": 308 - }, - "While trying to update the implicit return value 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 170 - } - }, - "688": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 57, - "offset": 2 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 389, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 385, - "__main__.unpack_composite_packed_task.pedersen_ptr": 386, - "__main__.unpack_composite_packed_task.poseidon_ptr": 387, - "__main__.unpack_composite_packed_task.range_check_ptr": 388, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 35, - "end_line": 171, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 35, - "end_line": 262, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 315, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 315 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 262 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 9, - "start_line": 308 - }, - "While trying to update the implicit return value 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 171 - } - }, - "689": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 57, - "offset": 3 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 389, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 385, - "__main__.unpack_composite_packed_task.pedersen_ptr": 386, - "__main__.unpack_composite_packed_task.poseidon_ptr": 387, - "__main__.unpack_composite_packed_task.range_check_ptr": 388, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 172, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 263, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 315, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 315 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 263 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 9, - "start_line": 308 - }, - "While trying to update the implicit return value 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 172 - } - }, - "690": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 57, - "offset": 4 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 389, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 385, - "__main__.unpack_composite_packed_task.pedersen_ptr": 386, - "__main__.unpack_composite_packed_task.poseidon_ptr": 387, - "__main__.unpack_composite_packed_task.range_check_ptr": 388, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 173, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 10, - "end_line": 310, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 24, - "end_line": 264, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 315, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 315 - }, - "While trying to retrieve the implicit argument 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 264 - }, - "While expanding the reference 'n_total_tasks' in:" - ], - "start_col": 9, - "start_line": 308 - }, - "While trying to update the implicit return value 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 173 - } - }, - "691": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 57, - "offset": 5 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 389, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 385, - "__main__.unpack_composite_packed_task.pedersen_ptr": 386, - "__main__.unpack_composite_packed_task.poseidon_ptr": 387, - "__main__.unpack_composite_packed_task.range_check_ptr": 388, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 22, - "end_line": 300, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 23, - "end_line": 265, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 315, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 315 - }, - "While trying to retrieve the implicit argument 'task_output' in:" - ], - "start_col": 5, - "start_line": 265 - }, - "While expanding the reference 'task_output' in:" - ], - "start_col": 11, - "start_line": 300 - } - }, - "692": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 57, - "offset": 6 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 389, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 390, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 385, - "__main__.unpack_composite_packed_task.pedersen_ptr": 386, - "__main__.unpack_composite_packed_task.poseidon_ptr": 387, - "__main__.unpack_composite_packed_task.range_check_ptr": 388, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 315, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 315 - } - }, - "693": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 0 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 392, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_output": 397 - } - }, - "hints": [], - "inst": { - "end_col": 24, - "end_line": 336, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 336 - } - }, - "695": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 2 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 392, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_output": 397 - } - }, - "hints": [], - "inst": { - "end_col": 23, - "end_line": 334, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 42, - "end_line": 240, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 63, - "end_line": 339, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 44, - "start_line": 339 - }, - "While trying to retrieve the implicit argument 'task_output' in:" - ], - "start_col": 24, - "start_line": 240 - }, - "While expanding the reference 'task_output' in:" - ], - "start_col": 5, - "start_line": 334 - } - }, - "696": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 3 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 392, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_output": 397 - } - }, - "hints": [], - "inst": { - "end_col": 63, - "end_line": 339, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 44, - "start_line": 339 - } - }, - "698": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 7 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 392, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 398 - } - }, - "hints": [], - "inst": { - "end_col": 44, - "end_line": 340, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 340 - } - }, - "699": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 7 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 392, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 400 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 343, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 52, - "start_line": 343 - } - }, - "700": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 8 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 392, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 400 - } - }, - "hints": [], - "inst": { - "end_col": 66, - "end_line": 343, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 343 - } - }, - "701": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 8 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 392, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 400 - } - }, - "hints": [], - "inst": { - "end_col": 65, - "end_line": 343, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 52, - "start_line": 343 - } - }, - "702": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 9 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 392, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 400 - } - }, - "hints": [], - "inst": { - "end_col": 66, - "end_line": 343, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 343 - } - }, - "703": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 9 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 403, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 400 - } - }, - "hints": [], - "inst": { - "end_col": 41, - "end_line": 349, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 25, - "start_line": 349 - } - }, - "704": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 10 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 403, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 400 - } - }, - "hints": [], - "inst": { - "end_col": 66, - "end_line": 349, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 349 - } - }, - "706": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 10 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 403, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 400 - } - }, - "hints": [], - "inst": { - "end_col": 56, - "end_line": 346, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 26, - "end_line": 350, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 16, - "start_line": 350 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 22, - "start_line": 346 - } - }, - "708": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 11 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 403, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 400 - } - }, - "hints": [], - "inst": { - "end_col": 22, - "end_line": 340, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 43, - "end_line": 350, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 32, - "start_line": 350 - }, - "While expanding the reference 'task_output' in:" - ], - "start_col": 11, - "start_line": 340 - } - }, - "709": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 12 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 403, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 400 - } - }, - "hints": [], - "inst": { - "end_col": 22, - "end_line": 349, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 60, - "end_line": 350, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 49, - "start_line": 350 - }, - "While expanding the reference 'output_size' in:" - ], - "start_col": 11, - "start_line": 349 - } - }, - "710": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 58, - "offset": 13 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 396, - "__main__.unpack_plain_packed_task.output_ptr": 403, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 400 - } - }, - "hints": [], - "inst": { - "end_col": 61, - "end_line": 350, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 350 - } - }, - "712": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 59, - "offset": 0 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 408, - "__main__.unpack_plain_packed_task.output_ptr": 406, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 407 - } - }, - "hints": [], - "inst": { - "end_col": 56, - "end_line": 346, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 32, - "end_line": 353, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 329, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 356, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 356 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 329 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 22, - "start_line": 353 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 22, - "start_line": 346 - } - }, - "714": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 59, - "offset": 1 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.__temp61": 409, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 408, - "__main__.unpack_plain_packed_task.output_ptr": 406, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 407 - } - }, - "hints": [], - "inst": { - "end_col": 46, - "end_line": 353, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 22, - "end_line": 329, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 356, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 356 - }, - "While trying to retrieve the implicit argument 'output_ptr' in:" - ], - "start_col": 5, - "start_line": 329 - }, - "While expanding the reference 'output_ptr' in:" - ], - "start_col": 22, - "start_line": 353 - } - }, - "715": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 59, - "offset": 2 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.__temp61": 409, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 408, - "__main__.unpack_plain_packed_task.output_ptr": 406, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 407 - } - }, - "hints": [], - "inst": { - "end_col": 31, - "end_line": 330, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 31, - "end_line": 330, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 356, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 356 - }, - "While trying to retrieve the implicit argument 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 330 - }, - "While expanding the reference 'pedersen_ptr' in:" - ], - "start_col": 5, - "start_line": 330 - } - }, - "716": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 59, - "offset": 3 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.__temp61": 409, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 408, - "__main__.unpack_plain_packed_task.output_ptr": 406, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 407 - } - }, - "hints": [], - "inst": { - "end_col": 35, - "end_line": 331, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 35, - "end_line": 331, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 356, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 356 - }, - "While trying to retrieve the implicit argument 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 331 - }, - "While expanding the reference 'poseidon_ptr' in:" - ], - "start_col": 5, - "start_line": 331 - } - }, - "717": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 59, - "offset": 4 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.__temp61": 409, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 408, - "__main__.unpack_plain_packed_task.output_ptr": 406, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 407 - } - }, - "hints": [], - "inst": { - "end_col": 20, - "end_line": 332, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 20, - "end_line": 332, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 356, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 356 - }, - "While trying to retrieve the implicit argument 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 332 - }, - "While expanding the reference 'range_check_ptr' in:" - ], - "start_col": 5, - "start_line": 332 - } - }, - "718": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 59, - "offset": 5 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.__temp61": 409, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 408, - "__main__.unpack_plain_packed_task.output_ptr": 406, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 407 - } - }, - "hints": [], - "inst": { - "end_col": 42, - "end_line": 355, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 24, - "end_line": 333, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 356, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 356 - }, - "While trying to retrieve the implicit argument 'n_total_tasks' in:" - ], - "start_col": 5, - "start_line": 333 - }, - "While expanding the reference 'n_total_tasks' in:" - ], - "start_col": 25, - "start_line": 355 - } - }, - "720": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 59, - "offset": 6 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.__temp61": 409, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 408, - "__main__.unpack_plain_packed_task.output_ptr": 406, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 407 - } - }, - "hints": [], - "inst": { - "end_col": 48, - "end_line": 354, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 23, - "end_line": 334, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "parent_location": [ - { - "end_col": 15, - "end_line": 356, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 356 - }, - "While trying to retrieve the implicit argument 'task_output' in:" - ], - "start_col": 5, - "start_line": 334 - }, - "While expanding the reference 'task_output' in:" - ], - "start_col": 23, - "start_line": 354 - } - }, - "721": { - "accessible_scopes": [ - "__main__", - "__main__.unpack_plain_packed_task" - ], - "flow_tracking_data": { - "ap_tracking": { - "group": 59, - "offset": 7 - }, - "reference_ids": { - "__main__.unpack_plain_packed_task.__temp58": 401, - "__main__.unpack_plain_packed_task.__temp59": 402, - "__main__.unpack_plain_packed_task.__temp60": 404, - "__main__.unpack_plain_packed_task.__temp61": 409, - "__main__.unpack_plain_packed_task.bootloader_config": 391, - "__main__.unpack_plain_packed_task.n_total_tasks": 408, - "__main__.unpack_plain_packed_task.output_ptr": 406, - "__main__.unpack_plain_packed_task.output_size": 405, - "__main__.unpack_plain_packed_task.pedersen_ptr": 393, - "__main__.unpack_plain_packed_task.poseidon_ptr": 394, - "__main__.unpack_plain_packed_task.range_check_ptr": 395, - "__main__.unpack_plain_packed_task.task_header": 399, - "__main__.unpack_plain_packed_task.task_output": 407 - } - }, - "hints": [], - "inst": { - "end_col": 15, - "end_line": 356, - "input_file": { - "filename": "/home/olivier/git/moonsong-labs/starkware/cairo-bootloader/dependencies/cairo-lang/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" - }, - "start_col": 5, - "start_line": 356 - } - } - } - }, - "hints": { - "12": [ - { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.inner_select_builtins", - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins" - ], - "code": "# A builtin should be selected iff its encoding appears in the selected encodings list\n# and the list wasn't exhausted.\n# Note that testing inclusion by a single comparison is possible since the lists are sorted.\nids.select_builtin = int(\n n_selected_builtins > 0 and memory[ids.selected_encodings] == memory[ids.all_encodings])\nif ids.select_builtin:\n n_selected_builtins = n_selected_builtins - 1", - "flow_tracking_data": { - "ap_tracking": { - "group": 2, - "offset": 3 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": 2, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": 3, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": 6, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": 7, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": 4, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": 5 - } - } - } - ], - "34": [ - { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "code": "vm_enter_scope({'n_selected_builtins': ids.n_selected_builtins})", - "flow_tracking_data": { - "ap_tracking": { - "group": 4, - "offset": 2 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - } - } - ], - "45": [ - { - "accessible_scopes": [ - "starkware.cairo.builtin_selection.select_input_builtins", - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins" - ], - "code": "vm_exit_scope()", - "flow_tracking_data": { - "ap_tracking": { - "group": 5, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": 19, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": 20, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": 10, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": 11, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": 17, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": 15, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": 21, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": 12, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": 14, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": 13, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": 18, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": 16 - } - } - } - ], - "83": [ - { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "code": "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= 10)", - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - } - } - ], - "145": [ - { - "accessible_scopes": [ - "starkware.cairo.common.builtin_poseidon.poseidon", - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many" - ], - "code": "memory[ap] = to_felt_or_relocatable(ids.elements_end - ids.elements >= 2)", - "flow_tracking_data": { - "ap_tracking": { - "group": 10, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": 43, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": 41, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": 39, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": 36, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": 42, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": 40 - } - } - } - ], - "236": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "code": "ids.program_data_ptr = program_data_base = segments.add()", - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 28 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - } - } - ], - "237": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "code": "from starkware.cairo.bootloaders.simple_bootloader.utils import load_program\n\n# Call load_program to load the program header and code to memory.\nprogram_address, program_data_size = load_program(\n task=task, memory=memory, program_header=ids.program_header,\n builtins_offset=ids.ProgramHeader.builtin_list)\nsegments.finalize(program_data_base.segment_index, program_data_size)", - "flow_tracking_data": { - "ap_tracking": { - "group": 16, - "offset": 28 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - } - } - ], - "247": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "code": "# Validate hash.\nfrom starkware.cairo.bootloaders.hash_program import compute_program_hash_chain\n\nassert memory[ids.output_ptr + 1] == compute_program_hash_chain(\n program=task.get_program(),\n use_poseidon=bool(ids.use_poseidon)), 'Computed hash does not match input.'", - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - } - } - ], - "251": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "code": "# Sanity check.\nassert ids.program_address == program_address", - "flow_tracking_data": { - "ap_tracking": { - "group": 17, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - } - } - ], - "272": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "code": "from starkware.cairo.bootloaders.simple_bootloader.objects import (\n CairoPieTask,\n RunProgramTask,\n Task,\n)\nfrom starkware.cairo.bootloaders.simple_bootloader.utils import (\n load_cairo_pie,\n prepare_output_runner,\n)\n\nassert isinstance(task, Task)\nn_builtins = len(task.get_program().builtins)\nnew_task_locals = {}\nif isinstance(task, RunProgramTask):\n new_task_locals['program_input'] = task.program_input\n new_task_locals['WITH_BOOTLOADER'] = True\n\n vm_load_program(task.program, program_address)\nelif isinstance(task, CairoPieTask):\n ret_pc = ids.ret_pc_label.instruction_offset_ - ids.call_task.instruction_offset_ + pc\n load_cairo_pie(\n task=task.cairo_pie, memory=memory, segments=segments,\n program_address=program_address, execution_segment_address= ap - n_builtins,\n builtin_runners=builtin_runners, ret_fp=fp, ret_pc=ret_pc)\nelse:\n raise NotImplementedError(f'Unexpected task type: {type(task).__name__}.')\n\noutput_runner_data = prepare_output_runner(\n task=task,\n output_builtin=output_builtin,\n output_ptr=ids.pre_execution_builtin_ptrs.output)\nvm_enter_scope(new_task_locals)", - "flow_tracking_data": { - "ap_tracking": { - "group": 18, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - } - } - ], - "273": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "code": "vm_exit_scope()\n# Note that bootloader_input will only be available in the next hint.", - "flow_tracking_data": { - "ap_tracking": { - "group": 19, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134 - } - } - } - ], - "276": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "code": "from starkware.cairo.bootloaders.simple_bootloader.utils import write_return_builtins\n\n# Fill the values of all builtin pointers after executing the task.\nbuiltins = task.get_program().builtins\nwrite_return_builtins(\n memory=memory, return_builtins_addr=ids.return_builtin_ptrs.address_,\n used_builtins=builtins, used_builtins_addr=ids.used_builtins_addr,\n pre_execution_builtins_addr=ids.pre_execution_builtin_ptrs.address_, task=task)\n\nvm_enter_scope({'n_selected_builtins': n_builtins})", - "flow_tracking_data": { - "ap_tracking": { - "group": 19, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - } - } - ], - "285": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "code": "vm_exit_scope()", - "flow_tracking_data": { - "ap_tracking": { - "group": 20, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 136, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - } - } - ], - "298": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.execute_task", - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task" - ], - "code": "from starkware.cairo.bootloaders.simple_bootloader.utils import get_task_fact_topology\n\n# Add the fact topology of the current task to 'fact_topologies'.\noutput_start = ids.pre_execution_builtin_ptrs.output\noutput_end = ids.return_builtin_ptrs.output\nfact_topologies.append(get_task_fact_topology(\n output_size=output_end - output_start,\n task=task,\n output_builtin=output_builtin,\n output_runner_data=output_runner_data,\n))", - "flow_tracking_data": { - "ap_tracking": { - "group": 21, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": 138, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": 143, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": 155, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": 132, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": 133, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": 149, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": 135, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": 148, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": 140, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": 150, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": 141, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": 160, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": 146, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": 147, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": 154, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": 151, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": 139, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": 153, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": 142, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": 152, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": 157, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": 158, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": 159, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": 134, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": 156 - } - } - } - ], - "304": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "code": "n_tasks = len(simple_bootloader_input.tasks)\nmemory[ids.output_ptr] = n_tasks\n\n# Task range checks are located right after simple bootloader validation range checks, and\n# this is validated later in this function.\nids.task_range_check_ptr = ids.range_check_ptr + ids.BuiltinData.SIZE * n_tasks\n\n# A list of fact_toplogies that instruct how to generate the fact from the program output\n# for each task.\nfact_topologies = []", - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 29 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 162, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - } - } - ], - "352": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader" - ], - "code": "tasks = simple_bootloader_input.tasks", - "flow_tracking_data": { - "ap_tracking": { - "group": 22, - "offset": 31 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": 177, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": 166, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": 175, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": 176, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": 174, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": 167, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": 165, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": 168, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": 172, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": 173, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": 163, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": 169, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": 170, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": 164, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": 171 - } - } - } - ], - "385": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative" - ], - "code": "memory[ap] = to_felt_or_relocatable(ids.num // 2)", - "flow_tracking_data": { - "ap_tracking": { - "group": 25, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": 195, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": 194 - } - } - } - ], - "401": [ - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "code": "from starkware.cairo.bootloaders.simple_bootloader.objects import Task\n\n# Pass current task to execute_task.\ntask_id = len(simple_bootloader_input.tasks) - ids.n_tasks\ntask = simple_bootloader_input.tasks[task_id].load_task()", - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 - } - } - }, - { - "accessible_scopes": [ - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader", - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks" - ], - "code": "memory[ap] = to_felt_or_relocatable(1 if task.use_poseidon else 0)", - "flow_tracking_data": { - "ap_tracking": { - "group": 27, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": 199, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": 200, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": 202, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": 201, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": 203 - } - } - } - ], - "417": [ - { - "accessible_scopes": [ - "starkware.cairo.common.math", - "starkware.cairo.common.math.assert_nn" - ], - "code": "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'", - "flow_tracking_data": { - "ap_tracking": { - "group": 30, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.math.assert_nn.a": 209, - "starkware.cairo.common.math.assert_nn.range_check_ptr": 210 - } - } - } - ], - "437": [ - { - "accessible_scopes": [ - "starkware.cairo.common.find_element", - "starkware.cairo.common.find_element.find_element" - ], - "code": "array_ptr = ids.array_ptr\nelm_size = ids.elm_size\nassert isinstance(elm_size, int) and elm_size > 0, \\\n f'Invalid value for elm_size. Got: {elm_size}.'\nkey = ids.key\n\nif '__find_element_index' in globals():\n ids.index = __find_element_index\n found_key = memory[array_ptr + elm_size * __find_element_index]\n assert found_key == key, \\\n f'Invalid index found in __find_element_index. index: {__find_element_index}, ' \\\n f'expected key {key}, found key: {found_key}.'\n # Delete __find_element_index to make sure it's not used for the next calls.\n del __find_element_index\nelse:\n n_elms = ids.n_elms\n assert isinstance(n_elms, int) and n_elms >= 0, \\\n f'Invalid value for n_elms. Got: {n_elms}.'\n if '__find_element_max_size' in globals():\n assert n_elms <= __find_element_max_size, \\\n f'find_element() can only be used with n_elms<={__find_element_max_size}. ' \\\n f'Got: n_elms={n_elms}.'\n\n for i in range(n_elms):\n if memory[array_ptr + elm_size * i] == key:\n ids.index = i\n break\n else:\n raise ValueError(f'Key {key} was not found.')", - "flow_tracking_data": { - "ap_tracking": { - "group": 33, - "offset": 1 - }, - "reference_ids": { - "starkware.cairo.common.find_element.find_element.array_ptr": 221, - "starkware.cairo.common.find_element.find_element.elm_size": 222, - "starkware.cairo.common.find_element.find_element.index": 226, - "starkware.cairo.common.find_element.find_element.key": 224, - "starkware.cairo.common.find_element.find_element.n_elms": 223, - "starkware.cairo.common.find_element.find_element.range_check_ptr": 225 - } - } - } - ], - "526": [ - { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "code": "vm_enter_scope({'n': ids.len})", - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 0 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - } - } - ], - "534": [ - { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "code": "n -= 1\nids.continue_copying = 1 if n > 0 else 0", - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 5 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.__temp53": 275, - "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.frame": 274, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.next_frame": 277, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - } - } - ], - "537": [ - { - "accessible_scopes": [ - "starkware.cairo.common.memcpy", - "starkware.cairo.common.memcpy.memcpy" - ], - "code": "vm_exit_scope()", - "flow_tracking_data": { - "ap_tracking": { - "group": 42, - "offset": 6 - }, - "reference_ids": { - "starkware.cairo.common.memcpy.memcpy.__temp53": 275, - "starkware.cairo.common.memcpy.memcpy.continue_copying": 276, - "starkware.cairo.common.memcpy.memcpy.dst": 270, - "starkware.cairo.common.memcpy.memcpy.frame": 274, - "starkware.cairo.common.memcpy.memcpy.len": 272, - "starkware.cairo.common.memcpy.memcpy.next_frame": 277, - "starkware.cairo.common.memcpy.memcpy.src": 271 - } - } - } - ], - "540": [ - { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "code": "from starkware.cairo.bootloaders.bootloader.objects import BootloaderInput\nbootloader_input = BootloaderInput.Schema().load(program_input)\n\nids.simple_bootloader_output_start = segments.add()\n\n# Change output builtin state to a different segment in preparation for calling the\n# simple bootloader.\noutput_builtin_state = output_builtin.get_state()\noutput_builtin.new_state(base=ids.simple_bootloader_output_start)", - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 11 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_start": 287 - } - } - }, - { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "code": "simple_bootloader_input = bootloader_input", - "flow_tracking_data": { - "ap_tracking": { - "group": 43, - "offset": 11 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 282, - "__main__.main.ec_op_ptr": 283, - "__main__.main.ecdsa_ptr": 281, - "__main__.main.keccak_ptr": 284, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 279, - "__main__.main.poseidon_ptr": 285, - "__main__.main.range_check96_ptr": 286, - "__main__.main.range_check_ptr": 280, - "__main__.main.simple_bootloader_output_ptr": 288, - "__main__.main.simple_bootloader_output_start": 287 - } - } - } - ], - "559": [ - { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "code": "# Restore the bootloader's output builtin state.\noutput_builtin.set_state(output_builtin_state)", - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - } - }, - { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "code": "from starkware.cairo.bootloaders.bootloader.objects import BootloaderConfig\nbootloader_config: BootloaderConfig = bootloader_input.bootloader_config\n\nids.bootloader_config = segments.gen_arg(\n [\n bootloader_config.simple_bootloader_program_hash,\n len(bootloader_config.supported_cairo_verifier_program_hashes),\n bootloader_config.supported_cairo_verifier_program_hashes,\n ],\n)", - "flow_tracking_data": { - "ap_tracking": { - "group": 44, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_ptr": 278, - "__main__.main.pedersen_ptr": 290, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - } - } - ], - "565": [ - { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "code": "output_start = ids.output_ptr", - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 289, - "__main__.main.simple_bootloader_output_start": 287 - } - } - }, - { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "code": "packed_outputs = bootloader_input.packed_outputs", - "flow_tracking_data": { - "ap_tracking": { - "group": 45, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 314, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 310, - "__main__.main.pedersen_ptr": 308, - "__main__.main.poseidon_ptr": 303, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 298, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 313, - "__main__.main.simple_bootloader_output_start": 287 - } - } - } - ], - "580": [ - { - "accessible_scopes": [ - "__main__", - "__main__.main" - ], - "code": "from typing import List\n\nfrom starkware.cairo.bootloaders.bootloader.utils import compute_fact_topologies\nfrom starkware.cairo.bootloaders.fact_topology import FactTopology\nfrom starkware.cairo.bootloaders.simple_bootloader.utils import (\n configure_fact_topologies,\n write_to_fact_topologies_file,\n)\n\n# Compute the fact topologies of the plain packed outputs based on packed_outputs and\n# fact_topologies of the inner tasks.\nplain_fact_topologies: List[FactTopology] = compute_fact_topologies(\n packed_outputs=packed_outputs, fact_topologies=fact_topologies,\n)\n\n# Configure the memory pages in the output builtin, based on plain_fact_topologies.\nconfigure_fact_topologies(\n fact_topologies=plain_fact_topologies, output_start=output_start,\n output_builtin=output_builtin,\n)\n\n# Dump fact topologies to a json file.\nif bootloader_input.fact_topologies_path is not None:\n write_to_fact_topologies_file(\n fact_topologies_path=bootloader_input.fact_topologies_path,\n fact_topologies=plain_fact_topologies,\n )", - "flow_tracking_data": { - "ap_tracking": { - "group": 46, - "offset": 0 - }, - "reference_ids": { - "__main__.main.bitwise_ptr": 300, - "__main__.main.bootloader_config": 306, - "__main__.main.ec_op_ptr": 301, - "__main__.main.ecdsa_ptr": 299, - "__main__.main.keccak_ptr": 302, - "__main__.main.n_subtasks": 312, - "__main__.main.n_total_tasks": 319, - "__main__.main.output_n_total_tasks_ptr": 309, - "__main__.main.output_ptr": 315, - "__main__.main.parse_tasks_end": 321, - "__main__.main.pedersen_ptr": 316, - "__main__.main.poseidon_ptr": 317, - "__main__.main.range_check96_ptr": 304, - "__main__.main.range_check_ptr": 318, - "__main__.main.simple_bootloader_output_end": 305, - "__main__.main.simple_bootloader_output_ptr": 320, - "__main__.main.simple_bootloader_output_start": 287 - } - } - } - ], - "601": [ - { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "code": "from starkware.cairo.bootloaders.bootloader.objects import PackedOutput\n\ntask_id = len(packed_outputs) - ids.n_subtasks\npacked_output: PackedOutput = packed_outputs[task_id]\n\nvm_enter_scope(new_scope_locals=dict(packed_output=packed_output))", - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - } - }, - { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "code": "from starkware.cairo.bootloaders.bootloader.objects import (\n CompositePackedOutput,\n PlainPackedOutput,\n)", - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - } - }, - { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "code": "memory[ap] = to_felt_or_relocatable(isinstance(packed_output, PlainPackedOutput))", - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - } - } - ], - "605": [ - { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "code": "assert isinstance(packed_output, CompositePackedOutput)", - "flow_tracking_data": { - "ap_tracking": { - "group": 47, - "offset": 1 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 328, - "__main__.parse_tasks.output_ptr": 324, - "__main__.parse_tasks.pedersen_ptr": 325, - "__main__.parse_tasks.poseidon_ptr": 326, - "__main__.parse_tasks.range_check_ptr": 327, - "__main__.parse_tasks.subtasks_output": 329 - } - } - } - ], - "625": [ - { - "accessible_scopes": [ - "__main__", - "__main__.parse_tasks" - ], - "code": "vm_exit_scope()", - "flow_tracking_data": { - "ap_tracking": { - "group": 50, - "offset": 0 - }, - "reference_ids": { - "__main__.parse_tasks.__temp54": 330, - "__main__.parse_tasks.bootloader_config": 322, - "__main__.parse_tasks.n_subtasks": 323, - "__main__.parse_tasks.n_total_tasks": 347, - "__main__.parse_tasks.output_ptr": 343, - "__main__.parse_tasks.pedersen_ptr": 344, - "__main__.parse_tasks.poseidon_ptr": 345, - "__main__.parse_tasks.range_check_ptr": 346, - "__main__.parse_tasks.subtasks_output": 348 - } - } - } - ], - "649": [ - { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "code": "data = packed_output.elements_for_hash()\nids.nested_subtasks_output_len = len(data)\nids.nested_subtasks_output = segments.gen_arg(data)", - "flow_tracking_data": { - "ap_tracking": { - "group": 55, - "offset": 4 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 372, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 368, - "__main__.unpack_composite_packed_task.range_check_ptr": 369, - "__main__.unpack_composite_packed_task.task_output": 371 - } - } - } - ], - "674": [ - { - "accessible_scopes": [ - "__main__", - "__main__.unpack_composite_packed_task" - ], - "code": "packed_outputs = packed_output.subtasks", - "flow_tracking_data": { - "ap_tracking": { - "group": 56, - "offset": 38 - }, - "reference_ids": { - "__main__.unpack_composite_packed_task.__temp56": 378, - "__main__.unpack_composite_packed_task.__temp57": 380, - "__main__.unpack_composite_packed_task.bootloader_config": 365, - "__main__.unpack_composite_packed_task.n_subtasks": 383, - "__main__.unpack_composite_packed_task.n_total_tasks": 370, - "__main__.unpack_composite_packed_task.nested_subtasks_output": 384, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": 373, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": 382, - "__main__.unpack_composite_packed_task.output_ptr": 366, - "__main__.unpack_composite_packed_task.pedersen_ptr": 367, - "__main__.unpack_composite_packed_task.poseidon_ptr": 374, - "__main__.unpack_composite_packed_task.range_check_ptr": 379, - "__main__.unpack_composite_packed_task.subtasks_output_hash": 375, - "__main__.unpack_composite_packed_task.task_header": 377, - "__main__.unpack_composite_packed_task.task_output": 381 - } - } - } - ] - }, - "identifiers": { - "__main__.BootloaderConfig": { - "full_name": "__main__.BootloaderConfig", - "members": { - "simple_bootloader_program_hash": { - "cairo_type": "felt", - "offset": 0 - }, - "supported_cairo_verifier_program_hashes": { - "cairo_type": "felt*", - "offset": 2 - }, - "supported_cairo_verifier_program_hashes_len": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 3, - "type": "struct" - }, - "__main__.CairoVerifierOutput": { - "destination": "starkware.cairo.cairo_verifier.objects.CairoVerifierOutput", - "type": "alias" - }, - "__main__.HashBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "type": "alias" - }, - "__main__.PoseidonBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", - "type": "alias" - }, - "__main__.TaskOutputHeader": { - "full_name": "__main__.TaskOutputHeader", - "members": { - "program_hash": { - "cairo_type": "felt", - "offset": 1 - }, - "size": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 2, - "type": "struct" - }, - "__main__.find_element": { - "destination": "starkware.cairo.common.find_element.find_element", - "type": "alias" - }, - "__main__.hash_felts": { - "destination": "starkware.cairo.common.hash_state.hash_felts", - "type": "alias" - }, - "__main__.main": { - "decorators": [], - "pc": 538, - "type": "function" - }, - "__main__.main.Args": { - "full_name": "__main__.main.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__main__.main.ImplicitArgs": { - "full_name": "__main__.main.ImplicitArgs", - "members": { - "bitwise_ptr": { - "cairo_type": "felt", - "offset": 4 - }, - "ec_op_ptr": { - "cairo_type": "felt", - "offset": 5 - }, - "ecdsa_ptr": { - "cairo_type": "felt", - "offset": 3 - }, - "keccak_ptr": { - "cairo_type": "felt", - "offset": 6 - }, - "output_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "offset": 7 - }, - "range_check96_ptr": { - "cairo_type": "felt", - "offset": 8 - }, - "range_check_ptr": { - "cairo_type": "felt", - "offset": 2 - } - }, - "size": 9, - "type": "struct" - }, - "__main__.main.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "__main__.main.SIZEOF_LOCALS": { - "type": "const", - "value": 11 - }, - "__main__.main.bitwise_ptr": { - "cairo_type": "felt", - "full_name": "__main__.main.bitwise_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 554, - "value": "[cast(fp + 3, felt*)]" - } - ], - "type": "reference" - }, - "__main__.main.bootloader_config": { - "cairo_type": "__main__.BootloaderConfig*", - "full_name": "__main__.main.bootloader_config", - "references": [ - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 559, - "value": "[cast(fp + 9, __main__.BootloaderConfig**)]" - } - ], - "type": "reference" - }, - "__main__.main.ec_op_ptr": { - "cairo_type": "felt", - "full_name": "__main__.main.ec_op_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 555, - "value": "[cast(fp + 4, felt*)]" - } - ], - "type": "reference" - }, - "__main__.main.ecdsa_ptr": { - "cairo_type": "felt", - "full_name": "__main__.main.ecdsa_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-8), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 553, - "value": "[cast(fp + 2, felt*)]" - } - ], - "type": "reference" - }, - "__main__.main.keccak_ptr": { - "cairo_type": "felt", - "full_name": "__main__.main.keccak_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 556, - "value": "[cast(fp + 5, felt*)]" - } - ], - "type": "reference" - }, - "__main__.main.n_subtasks": { - "cairo_type": "felt", - "full_name": "__main__.main.n_subtasks", - "references": [ - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "[cast([fp], felt*)]" - } - ], - "type": "reference" - }, - "__main__.main.n_total_tasks": { - "cairo_type": "felt", - "full_name": "__main__.main.n_total_tasks", - "references": [ - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "cast(0, felt)" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-2), felt*)]" - } - ], - "type": "reference" - }, - "__main__.main.output_n_total_tasks_ptr": { - "cairo_type": "felt*", - "full_name": "__main__.main.output_n_total_tasks_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "[cast(fp + 10, felt**)]" - } - ], - "type": "reference" - }, - "__main__.main.output_ptr": { - "cairo_type": "felt*", - "full_name": "__main__.main.output_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-11), felt**)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 564, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "cast([ap + (-2)] + 1, felt*)" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-6), felt**)]" - } - ], - "type": "reference" - }, - "__main__.main.parse_tasks_end": { - "cairo_type": "felt*", - "full_name": "__main__.main.parse_tasks_end", - "references": [ - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-1), felt**)]" - } - ], - "type": "reference" - }, - "__main__.main.pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "__main__.main.pedersen_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 564, - "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "__main__.main.poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "full_name": "__main__.main.poseidon_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 557, - "value": "[cast(fp + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - } - ], - "type": "reference" - }, - "__main__.main.range_check96_ptr": { - "cairo_type": "felt", - "full_name": "__main__.main.range_check96_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 558, - "value": "[cast(fp + 7, felt*)]" - } - ], - "type": "reference" - }, - "__main__.main.range_check_ptr": { - "cairo_type": "felt", - "full_name": "__main__.main.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-9), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 552, - "value": "[cast(fp + 1, felt*)]" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-3), felt*)]" - } - ], - "type": "reference" - }, - "__main__.main.simple_bootloader_output_end": { - "cairo_type": "felt*", - "full_name": "__main__.main.simple_bootloader_output_end", - "references": [ - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 559, - "value": "[cast(fp + 8, felt**)]" - } - ], - "type": "reference" - }, - "__main__.main.simple_bootloader_output_ptr": { - "cairo_type": "felt*", - "full_name": "__main__.main.simple_bootloader_output_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 11 - }, - "pc": 540, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-9), felt**)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "cast([fp] + 1, felt*)" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-1), felt**)]" - } - ], - "type": "reference" - }, - "__main__.main.simple_bootloader_output_start": { - "cairo_type": "felt*", - "full_name": "__main__.main.simple_bootloader_output_start", - "references": [ - { - "ap_tracking_data": { - "group": 43, - "offset": 11 - }, - "pc": 540, - "value": "[cast(fp, felt**)]" - } - ], - "type": "reference" - }, - "__main__.memcpy": { - "destination": "starkware.cairo.common.memcpy.memcpy", - "type": "alias" - }, - "__main__.parse_task_header": { - "decorators": [], - "pc": 643, - "type": "function" - }, - "__main__.parse_task_header.Args": { - "full_name": "__main__.parse_task_header.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "__main__.parse_task_header.ImplicitArgs": { - "full_name": "__main__.parse_task_header.ImplicitArgs", - "members": { - "task_output": { - "cairo_type": "felt*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "__main__.parse_task_header.Return": { - "cairo_type": "(task_header: __main__.TaskOutputHeader*)", - "type": "type_definition" - }, - "__main__.parse_task_header.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "__main__.parse_task_header.task_header": { - "cairo_type": "__main__.TaskOutputHeader*", - "full_name": "__main__.parse_task_header.task_header", - "references": [ - { - "ap_tracking_data": { - "group": 54, - "offset": 0 - }, - "pc": 643, - "value": "[cast(fp + (-3), __main__.TaskOutputHeader**)]" - } - ], - "type": "reference" - }, - "__main__.parse_task_header.task_output": { - "cairo_type": "felt*", - "full_name": "__main__.parse_task_header.task_output", - "references": [ - { - "ap_tracking_data": { - "group": 54, - "offset": 0 - }, - "pc": 643, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { - "group": 54, - "offset": 0 - }, - "pc": 643, - "value": "cast([fp + (-3)] + 2, felt*)" - } - ], - "type": "reference" - }, - "__main__.parse_tasks": { - "decorators": [], - "pc": 590, - "type": "function" - }, - "__main__.parse_tasks.Args": { - "full_name": "__main__.parse_tasks.Args", - "members": { - "bootloader_config": { - "cairo_type": "__main__.BootloaderConfig*", - "offset": 0 - }, - "n_subtasks": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "__main__.parse_tasks.ImplicitArgs": { - "full_name": "__main__.parse_tasks.ImplicitArgs", - "members": { - "n_total_tasks": { - "cairo_type": "felt", - "offset": 4 - }, - "output_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "offset": 2 - }, - "range_check_ptr": { - "cairo_type": "felt", - "offset": 3 - }, - "subtasks_output": { - "cairo_type": "felt*", - "offset": 5 - } - }, - "size": 6, - "type": "struct" - }, - "__main__.parse_tasks.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "__main__.parse_tasks.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "__main__.parse_tasks.__temp54": { - "cairo_type": "felt", - "full_name": "__main__.parse_tasks.__temp54", - "references": [ - { - "ap_tracking_data": { - "group": 47, - "offset": 1 - }, - "pc": 603, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "__main__.parse_tasks.bootloader_config": { - "cairo_type": "__main__.BootloaderConfig*", - "full_name": "__main__.parse_tasks.bootloader_config", - "references": [ - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-4), __main__.BootloaderConfig**)]" - } - ], - "type": "reference" - }, - "__main__.parse_tasks.n_subtasks": { - "cairo_type": "felt", - "full_name": "__main__.parse_tasks.n_subtasks", - "references": [ - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "__main__.parse_tasks.n_total_tasks": { - "cairo_type": "felt", - "full_name": "__main__.parse_tasks.n_total_tasks", - "references": [ - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-2), felt*)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-2), felt*)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-2), felt*)]" - } - ], - "type": "reference" - }, - "__main__.parse_tasks.output_ptr": { - "cairo_type": "felt*", - "full_name": "__main__.parse_tasks.output_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-10), felt**)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-6), felt**)]" - } - ], - "type": "reference" - }, - "__main__.parse_tasks.pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "__main__.parse_tasks.pedersen_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-9), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "__main__.parse_tasks.poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "full_name": "__main__.parse_tasks.poseidon_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - } - ], - "type": "reference" - }, - "__main__.parse_tasks.range_check_ptr": { - "cairo_type": "felt", - "full_name": "__main__.parse_tasks.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-3), felt*)]" - } - ], - "type": "reference" - }, - "__main__.parse_tasks.subtasks_output": { - "cairo_type": "felt*", - "full_name": "__main__.parse_tasks.subtasks_output", - "references": [ - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-1), felt**)]" - } - ], - "type": "reference" - }, - "__main__.poseidon_hash_many": { - "destination": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many", - "type": "alias" - }, - "__main__.run_simple_bootloader": { - "destination": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader", - "type": "alias" - }, - "__main__.serialize_bootloader_config": { - "decorators": [], - "pc": 631, - "type": "function" - }, - "__main__.serialize_bootloader_config.Args": { - "full_name": "__main__.serialize_bootloader_config.Args", - "members": { - "bootloader_config": { - "cairo_type": "__main__.BootloaderConfig*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "__main__.serialize_bootloader_config.ImplicitArgs": { - "full_name": "__main__.serialize_bootloader_config.ImplicitArgs", - "members": { - "output_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "__main__.serialize_bootloader_config.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "__main__.serialize_bootloader_config.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "__main__.serialize_bootloader_config.__temp55": { - "cairo_type": "felt", - "full_name": "__main__.serialize_bootloader_config.__temp55", - "references": [ - { - "ap_tracking_data": { - "group": 52, - "offset": 1 - }, - "pc": 632, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "__main__.serialize_bootloader_config.bootloader_config": { - "cairo_type": "__main__.BootloaderConfig*", - "full_name": "__main__.serialize_bootloader_config.bootloader_config", - "references": [ - { - "ap_tracking_data": { - "group": 52, - "offset": 0 - }, - "pc": 631, - "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" - } - ], - "type": "reference" - }, - "__main__.serialize_bootloader_config.output_ptr": { - "cairo_type": "felt*", - "full_name": "__main__.serialize_bootloader_config.output_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 52, - "offset": 0 - }, - "pc": 631, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { - "group": 53, - "offset": 0 - }, - "pc": 639, - "value": "cast([fp + (-5)] + 2, felt*)" - } - ], - "type": "reference" - }, - "__main__.serialize_bootloader_config.pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "__main__.serialize_bootloader_config.pedersen_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 52, - "offset": 0 - }, - "pc": 631, - "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 53, - "offset": 0 - }, - "pc": 638, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash": { - "cairo_type": "felt", - "full_name": "__main__.serialize_bootloader_config.supported_cairo_verifiers_hash", - "references": [ - { - "ap_tracking_data": { - "group": 53, - "offset": 0 - }, - "pc": 638, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task": { - "decorators": [], - "pc": 647, - "type": "function" - }, - "__main__.unpack_composite_packed_task.Args": { - "full_name": "__main__.unpack_composite_packed_task.Args", - "members": { - "bootloader_config": { - "cairo_type": "__main__.BootloaderConfig*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "__main__.unpack_composite_packed_task.ImplicitArgs": { - "full_name": "__main__.unpack_composite_packed_task.ImplicitArgs", - "members": { - "n_total_tasks": { - "cairo_type": "felt", - "offset": 4 - }, - "output_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "offset": 2 - }, - "range_check_ptr": { - "cairo_type": "felt", - "offset": 3 - }, - "task_output": { - "cairo_type": "felt*", - "offset": 5 - } - }, - "size": 6, - "type": "struct" - }, - "__main__.unpack_composite_packed_task.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "__main__.unpack_composite_packed_task.SIZEOF_LOCALS": { - "type": "const", - "value": 4 - }, - "__main__.unpack_composite_packed_task.__temp56": { - "cairo_type": "felt", - "full_name": "__main__.unpack_composite_packed_task.__temp56", - "references": [ - { - "ap_tracking_data": { - "group": 56, - "offset": 6 - }, - "pc": 659, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.__temp57": { - "cairo_type": "felt", - "full_name": "__main__.unpack_composite_packed_task.__temp57", - "references": [ - { - "ap_tracking_data": { - "group": 56, - "offset": 38 - }, - "pc": 669, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.bootloader_config": { - "cairo_type": "__main__.BootloaderConfig*", - "full_name": "__main__.unpack_composite_packed_task.bootloader_config", - "references": [ - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.n_subtasks": { - "cairo_type": "felt", - "full_name": "__main__.unpack_composite_packed_task.n_subtasks", - "references": [ - { - "ap_tracking_data": { - "group": 56, - "offset": 38 - }, - "pc": 674, - "value": "[cast([fp], felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.n_total_tasks": { - "cairo_type": "felt", - "full_name": "__main__.unpack_composite_packed_task.n_total_tasks", - "references": [ - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-2), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.nested_subtasks_output": { - "cairo_type": "felt*", - "full_name": "__main__.unpack_composite_packed_task.nested_subtasks_output", - "references": [ - { - "ap_tracking_data": { - "group": 55, - "offset": 4 - }, - "pc": 649, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 38 - }, - "pc": 674, - "value": "cast([fp] + 1, felt*)" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-1), felt**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.nested_subtasks_output_len": { - "cairo_type": "felt", - "full_name": "__main__.unpack_composite_packed_task.nested_subtasks_output_len", - "references": [ - { - "ap_tracking_data": { - "group": 55, - "offset": 4 - }, - "pc": 649, - "value": "[cast(fp + 1, felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.nested_subtasks_output_start": { - "cairo_type": "felt*", - "full_name": "__main__.unpack_composite_packed_task.nested_subtasks_output_start", - "references": [ - { - "ap_tracking_data": { - "group": 56, - "offset": 38 - }, - "pc": 674, - "value": "[cast(fp + 3, felt**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.output_ptr": { - "cairo_type": "felt*", - "full_name": "__main__.unpack_composite_packed_task.output_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-9), felt**)]" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-6), felt**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "__main__.unpack_composite_packed_task.pedersen_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "full_name": "__main__.unpack_composite_packed_task.poseidon_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 0 - }, - "pc": 654, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.range_check_ptr": { - "cairo_type": "felt", - "full_name": "__main__.unpack_composite_packed_task.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 37 - }, - "pc": 668, - "value": "[cast(ap + (-2), felt*)]" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-3), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.subtasks_output_hash": { - "cairo_type": "felt", - "full_name": "__main__.unpack_composite_packed_task.subtasks_output_hash", - "references": [ - { - "ap_tracking_data": { - "group": 56, - "offset": 0 - }, - "pc": 654, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.task_header": { - "cairo_type": "__main__.TaskOutputHeader*", - "full_name": "__main__.unpack_composite_packed_task.task_header", - "references": [ - { - "ap_tracking_data": { - "group": 56, - "offset": 5 - }, - "pc": 657, - "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_composite_packed_task.task_output": { - "cairo_type": "felt*", - "full_name": "__main__.unpack_composite_packed_task.task_output", - "references": [ - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 5 - }, - "pc": 657, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 38 - }, - "pc": 673, - "value": "[cast(fp + 2, felt**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task": { - "decorators": [], - "pc": 693, - "type": "function" - }, - "__main__.unpack_plain_packed_task.Args": { - "full_name": "__main__.unpack_plain_packed_task.Args", - "members": { - "bootloader_config": { - "cairo_type": "__main__.BootloaderConfig*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "__main__.unpack_plain_packed_task.ImplicitArgs": { - "full_name": "__main__.unpack_plain_packed_task.ImplicitArgs", - "members": { - "n_total_tasks": { - "cairo_type": "felt", - "offset": 4 - }, - "output_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "offset": 2 - }, - "range_check_ptr": { - "cairo_type": "felt", - "offset": 3 - }, - "task_output": { - "cairo_type": "felt*", - "offset": 5 - } - }, - "size": 6, - "type": "struct" - }, - "__main__.unpack_plain_packed_task.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "__main__.unpack_plain_packed_task.SIZEOF_LOCALS": { - "type": "const", - "value": 2 - }, - "__main__.unpack_plain_packed_task.__temp58": { - "cairo_type": "felt", - "full_name": "__main__.unpack_plain_packed_task.__temp58", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 8 - }, - "pc": 700, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.__temp59": { - "cairo_type": "felt", - "full_name": "__main__.unpack_plain_packed_task.__temp59", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 9 - }, - "pc": 702, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.__temp60": { - "cairo_type": "felt", - "full_name": "__main__.unpack_plain_packed_task.__temp60", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 10 - }, - "pc": 704, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.__temp61": { - "cairo_type": "felt", - "full_name": "__main__.unpack_plain_packed_task.__temp61", - "references": [ - { - "ap_tracking_data": { - "group": 59, - "offset": 1 - }, - "pc": 714, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.bootloader_config": { - "cairo_type": "__main__.BootloaderConfig*", - "full_name": "__main__.unpack_plain_packed_task.bootloader_config", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.n_total_tasks": { - "cairo_type": "felt", - "full_name": "__main__.unpack_plain_packed_task.n_total_tasks", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 59, - "offset": 0 - }, - "pc": 712, - "value": "cast([fp + (-5)] + 1, felt)" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.output_ptr": { - "cairo_type": "felt*", - "full_name": "__main__.unpack_plain_packed_task.output_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-9), felt**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 9 - }, - "pc": 703, - "value": "cast([fp + (-9)] + 2, felt*)" - }, - { - "ap_tracking_data": { - "group": 59, - "offset": 0 - }, - "pc": 712, - "value": "cast([fp + (-9)] + 2 + [fp + 1], felt*)" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.output_size": { - "cairo_type": "felt", - "full_name": "__main__.unpack_plain_packed_task.output_size", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 10 - }, - "pc": 706, - "value": "[cast(fp + 1, felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "__main__.unpack_plain_packed_task.pedersen_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "full_name": "__main__.unpack_plain_packed_task.poseidon_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.range_check_ptr": { - "cairo_type": "felt", - "full_name": "__main__.unpack_plain_packed_task.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-6), felt*)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.task_header": { - "cairo_type": "__main__.TaskOutputHeader*", - "full_name": "__main__.unpack_plain_packed_task.task_header", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 7 - }, - "pc": 698, - "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" - } - ], - "type": "reference" - }, - "__main__.unpack_plain_packed_task.task_output": { - "cairo_type": "felt*", - "full_name": "__main__.unpack_plain_packed_task.task_output", - "references": [ - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 7 - }, - "pc": 698, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 7 - }, - "pc": 699, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 59, - "offset": 0 - }, - "pc": 712, - "value": "cast([fp] + [fp + 1], felt*)" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.BOOTLOADER_VERSION": { - "type": "const", - "value": 0 - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", - "members": { - "bitwise": { - "cairo_type": "felt", - "offset": 4 - }, - "ec_op": { - "cairo_type": "felt", - "offset": 5 - }, - "ecdsa": { - "cairo_type": "felt", - "offset": 3 - }, - "keccak": { - "cairo_type": "felt", - "offset": 6 - }, - "output": { - "cairo_type": "felt", - "offset": 0 - }, - "pedersen": { - "cairo_type": "felt", - "offset": 1 - }, - "poseidon": { - "cairo_type": "felt", - "offset": 7 - }, - "range_check": { - "cairo_type": "felt", - "offset": 2 - }, - "range_check96": { - "cairo_type": "felt", - "offset": 8 - } - }, - "size": 9, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinList": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinList", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.HashBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.PoseidonBuiltin": { - "destination": "starkware.cairo.common.builtin_poseidon.poseidon.PoseidonBuiltin", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader", - "members": { - "bootloader_version": { - "cairo_type": "felt", - "offset": 1 - }, - "builtin_list": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinList", - "offset": 4 - }, - "data_length": { - "cairo_type": "felt", - "offset": 0 - }, - "n_builtins": { - "cairo_type": "felt", - "offset": 3 - }, - "program_main": { - "cairo_type": "felt", - "offset": 2 - } - }, - "size": 4, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash": { - "decorators": [], - "pc": 209, - "type": "function" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.Args": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.Args", - "members": { - "program_data_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "use_poseidon": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.ImplicitArgs": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.ImplicitArgs", - "members": { - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 0 - }, - "poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.Return": { - "cairo_type": "(hash: felt)", - "type": "type_definition" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.__temp45", - "references": [ - { - "ap_tracking_data": { - "group": 13, - "offset": 1 - }, - "pc": 211, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.hash", - "references": [ - { - "ap_tracking_data": { - "group": 14, - "offset": 0 - }, - "pc": 219, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 15, - "offset": 0 - }, - "pc": 227, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.pedersen_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 13, - "offset": 0 - }, - "pc": 209, - "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 15, - "offset": 0 - }, - "pc": 227, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.poseidon_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 13, - "offset": 0 - }, - "pc": 209, - "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 14, - "offset": 0 - }, - "pc": 219, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.program_data_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 13, - "offset": 0 - }, - "pc": 209, - "value": "[cast(fp + (-4), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.compute_program_hash.use_poseidon", - "references": [ - { - "ap_tracking_data": { - "group": 13, - "offset": 0 - }, - "pc": 209, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task": { - "decorators": [], - "pc": 231, - "type": "function" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.Args": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.Args", - "members": { - "builtin_encodings": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "offset": 0 - }, - "builtin_instance_sizes": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "offset": 1 - }, - "use_poseidon": { - "cairo_type": "felt", - "offset": 2 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ImplicitArgs": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ImplicitArgs", - "members": { - "builtin_ptrs": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "offset": 0 - }, - "self_range_check_ptr": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.SIZEOF_LOCALS": { - "type": "const", - "value": 26 - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__fp__", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 235, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 236, - "value": "[cast(fp, felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.__temp46", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 29 - }, - "pc": 239, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ap_val", - "references": [ - { - "ap_tracking_data": { - "group": 19, - "offset": 5 - }, - "pc": 275, - "value": "[cast(ap + (-1), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_encodings", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 0 - }, - "pc": 231, - "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_instance_sizes", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 0 - }, - "pc": 231, - "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_list", - "references": [ - { - "ap_tracking_data": { - "group": 17, - "offset": 0 - }, - "pc": 249, - "value": "[cast(fp + 3, felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.builtin_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 0 - }, - "pc": 231, - "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 21, - "offset": 0 - }, - "pc": 298, - "value": "cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.call_task": { - "pc": 272, - "type": "label" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.hash", - "references": [ - { - "ap_tracking_data": { - "group": 17, - "offset": 0 - }, - "pc": 246, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.input_builtin_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 236, - "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.n_builtins", - "references": [ - { - "ap_tracking_data": { - "group": 17, - "offset": 0 - }, - "pc": 250, - "value": "[cast(fp + 4, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 237, - "value": "[cast(fp + 2, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.output_size", - "references": [ - { - "ap_tracking_data": { - "group": 21, - "offset": 0 - }, - "pc": 297, - "value": "[cast(fp + 25, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pedersen_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 29 - }, - "pc": 240, - "value": "[cast([fp + (-7)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 0 - }, - "pc": 246, - "value": "[cast(ap + (-3), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.poseidon_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 29 - }, - "pc": 240, - "value": "[cast([fp + (-7)] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 0 - }, - "pc": 246, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.pre_execution_builtin_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 17, - "offset": 2 - }, - "pc": 263, - "value": "[cast(fp + 6, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_address", - "references": [ - { - "ap_tracking_data": { - "group": 17, - "offset": 1 - }, - "pc": 251, - "value": "[cast(ap + (-1), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_data_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 236, - "value": "[cast(fp + 1, felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_entry_point", - "references": [ - { - "ap_tracking_data": { - "group": 17, - "offset": 2 - }, - "pc": 253, - "value": "[cast(fp + 5, felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_header", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 237, - "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.program_main", - "references": [ - { - "ap_tracking_data": { - "group": 17, - "offset": 2 - }, - "pc": 252, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.ret_pc_label": { - "pc": 273, - "type": "label" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.return_builtin_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 19, - "offset": 5 - }, - "pc": 276, - "value": "[cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret": { - "cairo_type": "(selected_encodings_end: felt*)", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.select_builtins_ret", - "references": [ - { - "ap_tracking_data": { - "group": 20, - "offset": 0 - }, - "pc": 285, - "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.self_range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 0 - }, - "pc": 231, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 21, - "offset": 0 - }, - "pc": 296, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.use_poseidon", - "references": [ - { - "ap_tracking_data": { - "group": 16, - "offset": 0 - }, - "pc": 231, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task.used_builtins_addr", - "references": [ - { - "ap_tracking_data": { - "group": 19, - "offset": 5 - }, - "pc": 276, - "value": "[cast(fp + 15, felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.get_ap": { - "destination": "starkware.cairo.common.registers.get_ap", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.get_fp_and_pc": { - "destination": "starkware.cairo.common.registers.get_fp_and_pc", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.hash_chain": { - "destination": "starkware.cairo.common.hash_chain.hash_chain", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.inner_select_builtins": { - "destination": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.poseidon_hash_many": { - "destination": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.select_input_builtins": { - "destination": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.execute_task.validate_builtins": { - "destination": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.BuiltinData": { - "destination": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.HashBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.PoseidonBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_task": { - "destination": "starkware.cairo.bootloaders.simple_bootloader.execute_task.execute_task", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks": { - "decorators": [], - "pc": 396, - "type": "function" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.Args": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.Args", - "members": { - "builtin_encodings": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "offset": 0 - }, - "builtin_instance_sizes": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "offset": 1 - }, - "n_tasks": { - "cairo_type": "felt", - "offset": 2 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.ImplicitArgs": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.ImplicitArgs", - "members": { - "builtin_ptrs": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "offset": 0 - }, - "self_range_check_ptr": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_encodings", - "references": [ - { - "ap_tracking_data": { - "group": 27, - "offset": 0 - }, - "pc": 396, - "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_instance_sizes", - "references": [ - { - "ap_tracking_data": { - "group": 27, - "offset": 0 - }, - "pc": 396, - "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.builtin_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 27, - "offset": 0 - }, - "pc": 396, - "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 28, - "offset": 0 - }, - "pc": 410, - "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 29, - "offset": 0 - }, - "pc": 416, - "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.n_tasks", - "references": [ - { - "ap_tracking_data": { - "group": 27, - "offset": 0 - }, - "pc": 396, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.self_range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 27, - "offset": 0 - }, - "pc": 396, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 28, - "offset": 0 - }, - "pc": 410, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 29, - "offset": 0 - }, - "pc": 416, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.execute_tasks.use_poseidon", - "references": [ - { - "ap_tracking_data": { - "group": 27, - "offset": 1 - }, - "pc": 403, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.get_fp_and_pc": { - "destination": "starkware.cairo.common.registers.get_fp_and_pc", - "type": "alias" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader": { - "decorators": [], - "pc": 302, - "type": "function" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.Args": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ImplicitArgs": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ImplicitArgs", - "members": { - "bitwise_ptr": { - "cairo_type": "felt", - "offset": 4 - }, - "ec_op_ptr": { - "cairo_type": "felt", - "offset": 5 - }, - "ecdsa_ptr": { - "cairo_type": "felt", - "offset": 3 - }, - "keccak_ptr": { - "cairo_type": "felt", - "offset": 6 - }, - "output_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - }, - "poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "offset": 7 - }, - "range_check96_ptr": { - "cairo_type": "felt", - "offset": 8 - }, - "range_check_ptr": { - "cairo_type": "felt", - "offset": 2 - } - }, - "size": 9, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.SIZEOF_LOCALS": { - "type": "const", - "value": 29 - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__fp__", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 31 - }, - "pc": 352, - "value": "[cast(ap + (-2), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.__temp47", - "references": [ - { - "ap_tracking_data": { - "group": 23, - "offset": 1 - }, - "pc": 365, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.additional_range_checks", - "references": [ - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "cast([[fp + 28] + 2] - [ap + (-1)], felt)" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.bitwise_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 4, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_encodings", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 332, - "value": "[cast(fp + 10, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_instance_sizes", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 350, - "value": "[cast(fp + 19, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 31 - }, - "pc": 352, - "value": "cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 362, - "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast(fp + 28, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before": { - "cairo_type": "starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.builtin_ptrs_before", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 314, - "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ec_op_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 5, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.ecdsa_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-8), felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 3, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.keccak_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 6, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.n_tasks", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 304, - "value": "[cast([fp + (-11)], felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.output_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-11), felt**)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 304, - "value": "cast([fp + (-11)] + 1, felt*)" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28], felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.pedersen_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.poseidon_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check96_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 8, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-9), felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 2, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.self_range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 31 - }, - "pc": 352, - "value": "[cast(fp + (-9), felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 362, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.run_simple_bootloader.task_range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 304, - "value": "[cast(fp, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative": { - "decorators": [], - "pc": 380, - "type": "function" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.Args": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.Args", - "members": { - "n_bits": { - "cairo_type": "felt", - "offset": 1 - }, - "num": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.ImplicitArgs": { - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.__temp48", - "references": [ - { - "ap_tracking_data": { - "group": 25, - "offset": 2 - }, - "pc": 388, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.bit", - "references": [ - { - "ap_tracking_data": { - "group": 25, - "offset": 3 - }, - "pc": 389, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.n_bits", - "references": [ - { - "ap_tracking_data": { - "group": 25, - "offset": 0 - }, - "pc": 380, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num", - "references": [ - { - "ap_tracking_data": { - "group": 25, - "offset": 0 - }, - "pc": 380, - "value": "[cast(fp + (-4), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2": { - "cairo_type": "felt", - "full_name": "starkware.cairo.bootloaders.simple_bootloader.run_simple_bootloader.verify_non_negative.num_div2", - "references": [ - { - "ap_tracking_data": { - "group": 25, - "offset": 1 - }, - "pc": 387, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins": { - "decorators": [], - "pc": 6, - "type": "function" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.Args": { - "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.Args", - "members": { - "all_encodings": { - "cairo_type": "felt*", - "offset": 0 - }, - "all_ptrs": { - "cairo_type": "felt*", - "offset": 1 - }, - "n_builtins": { - "cairo_type": "felt", - "offset": 4 - }, - "selected_encodings": { - "cairo_type": "felt*", - "offset": 2 - }, - "selected_ptrs": { - "cairo_type": "felt*", - "offset": 3 - } - }, - "size": 5, - "type": "struct" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.FUNC_MEMORY_NO_BUILTINS": { - "type": "const", - "value": 1 - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.FUNC_MEMORY_WITH_BUILTINS": { - "type": "const", - "value": 10 - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.ImplicitArgs": { - "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.Return": { - "cairo_type": "(selected_encodings_end: felt*)", - "type": "type_definition" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.SIZEOF_LOCALS": { - "type": "const", - "value": 3 - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_encodings", - "references": [ - { - "ap_tracking_data": { - "group": 2, - "offset": 0 - }, - "pc": 6, - "value": "[cast(fp + (-7), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.all_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 2, - "offset": 0 - }, - "pc": 6, - "value": "[cast(fp + (-6), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_encoding", - "references": [ - { - "ap_tracking_data": { - "group": 2, - "offset": 3 - }, - "pc": 14, - "value": "[cast(fp + 1, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.curr_builtin_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 2, - "offset": 3 - }, - "pc": 15, - "value": "[cast(fp + 2, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.n_builtins", - "references": [ - { - "ap_tracking_data": { - "group": 2, - "offset": 0 - }, - "pc": 6, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.select_builtin", - "references": [ - { - "ap_tracking_data": { - "group": 2, - "offset": 3 - }, - "pc": 12, - "value": "[cast(fp, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_encodings", - "references": [ - { - "ap_tracking_data": { - "group": 2, - "offset": 0 - }, - "pc": 6, - "value": "[cast(fp + (-5), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins.selected_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 2, - "offset": 0 - }, - "pc": 6, - "value": "[cast(fp + (-4), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.get_fp_and_pc": { - "destination": "starkware.cairo.common.registers.get_fp_and_pc", - "type": "alias" - }, - "starkware.cairo.builtin_selection.select_input_builtins.inner_select_builtins": { - "destination": "starkware.cairo.builtin_selection.inner_select_builtins.inner_select_builtins", - "type": "alias" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins": { - "decorators": [], - "pc": 32, - "type": "function" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.Args": { - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.Args", - "members": { - "all_encodings": { - "cairo_type": "felt*", - "offset": 0 - }, - "all_ptrs": { - "cairo_type": "felt*", - "offset": 1 - }, - "n_all_builtins": { - "cairo_type": "felt", - "offset": 2 - }, - "n_selected_builtins": { - "cairo_type": "felt", - "offset": 4 - }, - "selected_encodings": { - "cairo_type": "felt*", - "offset": 3 - } - }, - "size": 5, - "type": "struct" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.FUNC_MEMORY_WITHOUT_INNER_FUNC": { - "type": "const", - "value": 11 - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.INNER_FUNC_MEMORY_FINAL_ITERATION": { - "type": "const", - "value": 1 - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.INNER_FUNC_MEMORY_PER_ITERATION": { - "type": "const", - "value": 10 - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.ImplicitArgs": { - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp0", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 3 - }, - "pc": 36, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.__temp1", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 4 - }, - "pc": 38, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_encodings", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "[cast(fp + (-7), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.all_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "[cast(fp + (-6), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame": { - "cairo_type": "(fp_val: felt*, pc_val: felt*)", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.frame", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 2 - }, - "pc": 34, - "value": "[cast(ap + (-2), (fp_val: felt*, pc_val: felt*)*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_func_memory", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "cast([fp + (-5)] * 10 + 1, felt)" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret": { - "cairo_type": "(selected_encodings_end: felt*)", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.inner_ret", - "references": [ - { - "ap_tracking_data": { - "group": 5, - "offset": 0 - }, - "pc": 45, - "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_all_builtins", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "[cast(fp + (-5), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.n_selected_builtins", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_encodings", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "[cast(fp + (-4), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.selected_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 2 - }, - "pc": 34, - "value": "cast([ap + (-2)] + [fp + (-5)] * 10 + 12, felt*)" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.select_input_builtins.select_input_builtins.total_func_memory", - "references": [ - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "cast([fp + (-5)] * 10 + 12, felt)" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin": { - "decorators": [], - "pc": 48, - "type": "function" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.Args": { - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.Args", - "members": { - "builtin_instance_size": { - "cairo_type": "felt", - "offset": 2 - }, - "new_builtin_ptr": { - "cairo_type": "felt*", - "offset": 1 - }, - "prev_builtin_ptr": { - "cairo_type": "felt*", - "offset": 0 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.ImplicitArgs": { - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.ImplicitArgs", - "members": { - "range_check_ptr": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.builtin_instance_size", - "references": [ - { - "ap_tracking_data": { - "group": 7, - "offset": 0 - }, - "pc": 48, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.diff", - "references": [ - { - "ap_tracking_data": { - "group": 7, - "offset": 1 - }, - "pc": 49, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.div_res", - "references": [ - { - "ap_tracking_data": { - "group": 7, - "offset": 2 - }, - "pc": 50, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.new_builtin_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 7, - "offset": 0 - }, - "pc": 48, - "value": "[cast(fp + (-4), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.prev_builtin_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 7, - "offset": 0 - }, - "pc": 48, - "value": "[cast(fp + (-5), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtin.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 7, - "offset": 0 - }, - "pc": 48, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 7, - "offset": 2 - }, - "pc": 51, - "value": "cast([fp + (-6)] + 1, felt)" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins": { - "decorators": [], - "pc": 54, - "type": "function" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.Args": { - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.Args", - "members": { - "builtin_instance_sizes": { - "cairo_type": "felt*", - "offset": 2 - }, - "n_builtins": { - "cairo_type": "felt", - "offset": 3 - }, - "new_builtin_ptrs": { - "cairo_type": "felt*", - "offset": 1 - }, - "prev_builtin_ptrs": { - "cairo_type": "felt*", - "offset": 0 - } - }, - "size": 4, - "type": "struct" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.ImplicitArgs": { - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.ImplicitArgs", - "members": { - "range_check_ptr": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.builtin_instance_sizes", - "references": [ - { - "ap_tracking_data": { - "group": 8, - "offset": 0 - }, - "pc": 54, - "value": "[cast(fp + (-4), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.n_builtins", - "references": [ - { - "ap_tracking_data": { - "group": 8, - "offset": 0 - }, - "pc": 54, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.new_builtin_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 8, - "offset": 0 - }, - "pc": 54, - "value": "[cast(fp + (-5), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.prev_builtin_ptrs", - "references": [ - { - "ap_tracking_data": { - "group": 8, - "offset": 0 - }, - "pc": 54, - "value": "[cast(fp + (-6), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.builtin_selection.validate_builtins.validate_builtins.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 8, - "offset": 0 - }, - "pc": 54, - "value": "[cast(fp + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 8, - "offset": 9 - }, - "pc": 64, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 9, - "offset": 0 - }, - "pc": 74, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.cairo_verifier.objects.CairoVerifierOutput": { - "full_name": "starkware.cairo.cairo_verifier.objects.CairoVerifierOutput", - "members": { - "output_hash": { - "cairo_type": "felt", - "offset": 1 - }, - "program_hash": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.bool.FALSE": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.bool.TRUE": { - "type": "const", - "value": 1 - }, - "starkware.cairo.common.builtin_poseidon.poseidon.PoseidonBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", - "type": "alias" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.PoseidonBuiltinState": { - "destination": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", - "type": "alias" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many": { - "decorators": [], - "pc": 75, - "type": "function" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.Args": { - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.Args", - "members": { - "elements": { - "cairo_type": "felt*", - "offset": 1 - }, - "n": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.ImplicitArgs": { - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.ImplicitArgs", - "members": { - "poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.Return": { - "cairo_type": "(res: felt)", - "type": "type_definition" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp10", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 14 - }, - "pc": 101, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp11", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 15 - }, - "pc": 102, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp12", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 16 - }, - "pc": 103, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp13", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 17 - }, - "pc": 105, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp14", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 18 - }, - "pc": 107, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp15", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 19 - }, - "pc": 108, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp16", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 20 - }, - "pc": 109, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp17", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 21 - }, - "pc": 111, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp18", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 22 - }, - "pc": 112, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp19", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 23 - }, - "pc": 113, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp2", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 6 - }, - "pc": 85, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp20", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 24 - }, - "pc": 115, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp21", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 25 - }, - "pc": 117, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp22", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 26 - }, - "pc": 118, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp23", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 27 - }, - "pc": 119, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp24", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 28 - }, - "pc": 121, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp25", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 29 - }, - "pc": 122, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp26", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 30 - }, - "pc": 123, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp27", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 31 - }, - "pc": 125, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp28", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 32 - }, - "pc": 127, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp29", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 33 - }, - "pc": 128, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp3", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 7 - }, - "pc": 90, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp30", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 34 - }, - "pc": 129, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp31", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 35 - }, - "pc": 131, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp32", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 36 - }, - "pc": 132, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp33", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 37 - }, - "pc": 133, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp34", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 38 - }, - "pc": 135, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp35", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 7 - }, - "pc": 147, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp36", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 8 - }, - "pc": 152, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp37", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 9 - }, - "pc": 153, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp38", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 155, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp39", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 11 - }, - "pc": 156, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp4", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 8 - }, - "pc": 91, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp40", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 8 - }, - "pc": 168, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp41", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 173, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp42", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 183, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp43", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 11 - }, - "pc": 184, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp44", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 12 - }, - "pc": 187, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp5", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 9 - }, - "pc": 93, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp6", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 94, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp7", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 11 - }, - "pc": 97, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp8", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 12 - }, - "pc": 98, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.__temp9", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 13 - }, - "pc": 99, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 0 - }, - "pc": 75, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 4 - }, - "pc": 82, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 42 - }, - "pc": 141, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 15 - }, - "pc": 163, - "value": "[cast(ap + (-1), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.elements_end", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 0 - }, - "pc": 75, - "value": "cast([fp + (-3)] + [fp + (-4)], felt*)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.loop": { - "pc": 83, - "type": "label" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.n", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 0 - }, - "pc": 75, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 9 - }, - "pc": 169, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin*", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.poseidon_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 0 - }, - "pc": 75, - "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 5 - }, - "pc": 83, - "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 96, - "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 17 - }, - "pc": 106, - "value": "cast([ap + (-13)] + 12, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 24 - }, - "pc": 116, - "value": "cast([ap + (-20)] + 18, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 31 - }, - "pc": 126, - "value": "cast([ap + (-27)] + 24, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 38 - }, - "pc": 136, - "value": "cast([ap + (-34)] + 30, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 43 - }, - "pc": 143, - "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 11 - }, - "pc": 158, - "value": "cast([ap + (-7)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 16 - }, - "pc": 165, - "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 176, - "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 12 - }, - "pc": 189, - "value": "cast([ap + (-8)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.res", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 176, - "value": "[cast([ap + (-6)] + 3, felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 12 - }, - "pc": 189, - "value": "[cast([ap + (-8)] + 3, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state": { - "cairo_type": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", - "full_name": "starkware.cairo.common.builtin_poseidon.poseidon.poseidon_hash_many.state", - "references": [ - { - "ap_tracking_data": { - "group": 10, - "offset": 3 - }, - "pc": 81, - "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 96, - "value": "[cast([ap + (-6)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 17 - }, - "pc": 106, - "value": "[cast([ap + (-13)] + 9, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 24 - }, - "pc": 116, - "value": "[cast([ap + (-20)] + 15, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 31 - }, - "pc": 126, - "value": "[cast([ap + (-27)] + 21, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 38 - }, - "pc": 136, - "value": "[cast([ap + (-34)] + 27, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 41 - }, - "pc": 139, - "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 11 - }, - "pc": 158, - "value": "[cast([ap + (-7)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 14 - }, - "pc": 161, - "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.cairo_builtins.BitwiseBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", - "members": { - "x": { - "cairo_type": "felt", - "offset": 0 - }, - "x_and_y": { - "cairo_type": "felt", - "offset": 2 - }, - "x_or_y": { - "cairo_type": "felt", - "offset": 4 - }, - "x_xor_y": { - "cairo_type": "felt", - "offset": 3 - }, - "y": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 5, - "type": "struct" - }, - "starkware.cairo.common.cairo_builtins.EcOpBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.EcOpBuiltin", - "members": { - "m": { - "cairo_type": "felt", - "offset": 4 - }, - "p": { - "cairo_type": "starkware.cairo.common.ec_point.EcPoint", - "offset": 0 - }, - "q": { - "cairo_type": "starkware.cairo.common.ec_point.EcPoint", - "offset": 2 - }, - "r": { - "cairo_type": "starkware.cairo.common.ec_point.EcPoint", - "offset": 5 - } - }, - "size": 7, - "type": "struct" - }, - "starkware.cairo.common.cairo_builtins.EcPoint": { - "destination": "starkware.cairo.common.ec_point.EcPoint", - "type": "alias" - }, - "starkware.cairo.common.cairo_builtins.HashBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "members": { - "result": { - "cairo_type": "felt", - "offset": 2 - }, - "x": { - "cairo_type": "felt", - "offset": 0 - }, - "y": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.cairo_builtins.KeccakBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.KeccakBuiltin", - "members": { - "input": { - "cairo_type": "starkware.cairo.common.keccak_state.KeccakBuiltinState", - "offset": 0 - }, - "output": { - "cairo_type": "starkware.cairo.common.keccak_state.KeccakBuiltinState", - "offset": 8 - } - }, - "size": 16, - "type": "struct" - }, - "starkware.cairo.common.cairo_builtins.KeccakBuiltinState": { - "destination": "starkware.cairo.common.keccak_state.KeccakBuiltinState", - "type": "alias" - }, - "starkware.cairo.common.cairo_builtins.PoseidonBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.PoseidonBuiltin", - "members": { - "input": { - "cairo_type": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", - "offset": 0 - }, - "output": { - "cairo_type": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", - "offset": 3 - } - }, - "size": 6, - "type": "struct" - }, - "starkware.cairo.common.cairo_builtins.PoseidonBuiltinState": { - "destination": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", - "type": "alias" - }, - "starkware.cairo.common.cairo_builtins.SignatureBuiltin": { - "full_name": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", - "members": { - "message": { - "cairo_type": "felt", - "offset": 1 - }, - "pub_key": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.ec_point.EcPoint": { - "full_name": "starkware.cairo.common.ec_point.EcPoint", - "members": { - "x": { - "cairo_type": "felt", - "offset": 0 - }, - "y": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.find_element.FIND_ELEMENT_RANGE_CHECK_USAGE": { - "type": "const", - "value": 2 - }, - "starkware.cairo.common.find_element.assert_le": { - "destination": "starkware.cairo.common.math.assert_le", - "type": "alias" - }, - "starkware.cairo.common.find_element.assert_le_felt": { - "destination": "starkware.cairo.common.math.assert_le_felt", - "type": "alias" - }, - "starkware.cairo.common.find_element.assert_lt_felt": { - "destination": "starkware.cairo.common.math.assert_lt_felt", - "type": "alias" - }, - "starkware.cairo.common.find_element.assert_nn_le": { - "destination": "starkware.cairo.common.math.assert_nn_le", - "type": "alias" - }, - "starkware.cairo.common.find_element.find_element": { - "decorators": [], - "pc": 435, - "type": "function" - }, - "starkware.cairo.common.find_element.find_element.Args": { - "full_name": "starkware.cairo.common.find_element.find_element.Args", - "members": { - "array_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "elm_size": { - "cairo_type": "felt", - "offset": 1 - }, - "key": { - "cairo_type": "felt", - "offset": 3 - }, - "n_elms": { - "cairo_type": "felt", - "offset": 2 - } - }, - "size": 4, - "type": "struct" - }, - "starkware.cairo.common.find_element.find_element.ImplicitArgs": { - "full_name": "starkware.cairo.common.find_element.find_element.ImplicitArgs", - "members": { - "range_check_ptr": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.find_element.find_element.Return": { - "cairo_type": "(elm_ptr: felt*)", - "type": "type_definition" - }, - "starkware.cairo.common.find_element.find_element.SIZEOF_LOCALS": { - "type": "const", - "value": 1 - }, - "starkware.cairo.common.find_element.find_element.__temp49": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.find_element.find_element.__temp49", - "references": [ - { - "ap_tracking_data": { - "group": 33, - "offset": 21 - }, - "pc": 444, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.find_element.find_element.array_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.find_element.find_element.array_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 33, - "offset": 0 - }, - "pc": 435, - "value": "[cast(fp + (-6), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.find_element.find_element.elm_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.find_element.find_element.elm_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 33, - "offset": 22 - }, - "pc": 445, - "value": "[cast(ap + (-1), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.find_element.find_element.elm_size": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.find_element.find_element.elm_size", - "references": [ - { - "ap_tracking_data": { - "group": 33, - "offset": 0 - }, - "pc": 435, - "value": "[cast(fp + (-5), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.find_element.find_element.index": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.find_element.find_element.index", - "references": [ - { - "ap_tracking_data": { - "group": 33, - "offset": 1 - }, - "pc": 437, - "value": "[cast(fp, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.find_element.find_element.key": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.find_element.find_element.key", - "references": [ - { - "ap_tracking_data": { - "group": 33, - "offset": 0 - }, - "pc": 435, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.find_element.find_element.n_elms": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.find_element.find_element.n_elms", - "references": [ - { - "ap_tracking_data": { - "group": 33, - "offset": 0 - }, - "pc": 435, - "value": "[cast(fp + (-4), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.find_element.find_element.range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.find_element.find_element.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 33, - "offset": 0 - }, - "pc": 435, - "value": "[cast(fp + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 33, - "offset": 20 - }, - "pc": 443, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash.HashBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "type": "alias" - }, - "starkware.cairo.common.hash.hash2": { - "decorators": [], - "pc": 449, - "type": "function" - }, - "starkware.cairo.common.hash.hash2.Args": { - "full_name": "starkware.cairo.common.hash.hash2.Args", - "members": { - "x": { - "cairo_type": "felt", - "offset": 0 - }, - "y": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.hash.hash2.ImplicitArgs": { - "full_name": "starkware.cairo.common.hash.hash2.ImplicitArgs", - "members": { - "hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.hash.hash2.Return": { - "cairo_type": "(result: felt)", - "type": "type_definition" - }, - "starkware.cairo.common.hash.hash2.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.hash.hash2.hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "starkware.cairo.common.hash.hash2.hash_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 34, - "offset": 0 - }, - "pc": 449, - "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 34, - "offset": 0 - }, - "pc": 451, - "value": "cast([fp + (-5)] + 3, starkware.cairo.common.cairo_builtins.HashBuiltin*)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash.hash2.result": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash.hash2.result", - "references": [ - { - "ap_tracking_data": { - "group": 34, - "offset": 0 - }, - "pc": 451, - "value": "[cast([fp + (-5)] + 2, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash.hash2.x": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash.hash2.x", - "references": [ - { - "ap_tracking_data": { - "group": 34, - "offset": 0 - }, - "pc": 449, - "value": "[cast(fp + (-4), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash.hash2.y": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash.hash2.y", - "references": [ - { - "ap_tracking_data": { - "group": 34, - "offset": 0 - }, - "pc": 449, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_chain.HashBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "type": "alias" - }, - "starkware.cairo.common.hash_chain.hash_chain": { - "decorators": [], - "pc": 193, - "type": "function" - }, - "starkware.cairo.common.hash_chain.hash_chain.Args": { - "full_name": "starkware.cairo.common.hash_chain.hash_chain.Args", - "members": { - "data_ptr": { - "cairo_type": "felt*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.hash_chain.hash_chain.ImplicitArgs": { - "full_name": "starkware.cairo.common.hash_chain.hash_chain.ImplicitArgs", - "members": { - "hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.hash_chain.hash_chain.LoopLocals": { - "full_name": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals", - "members": { - "cur_hash": { - "cairo_type": "felt", - "offset": 2 - }, - "data_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.hash_chain.hash_chain.Return": { - "cairo_type": "(hash: felt)", - "type": "type_definition" - }, - "starkware.cairo.common.hash_chain.hash_chain.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.hash_chain.hash_chain.curr_frame": { - "cairo_type": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals*", - "full_name": "starkware.cairo.common.hash_chain.hash_chain.curr_frame", - "references": [ - { - "ap_tracking_data": { - "group": 12, - "offset": 4 - }, - "pc": 197, - "value": "cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_chain.hash_chain.current_hash": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "starkware.cairo.common.hash_chain.hash_chain.current_hash", - "references": [ - { - "ap_tracking_data": { - "group": 12, - "offset": 4 - }, - "pc": 197, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_chain.hash_chain.data_length": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_chain.hash_chain.data_length", - "references": [ - { - "ap_tracking_data": { - "group": 12, - "offset": 1 - }, - "pc": 194, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.hash_chain.hash_chain.data_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 12, - "offset": 0 - }, - "pc": 193, - "value": "[cast(fp + (-3), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.hash_chain.hash_chain.data_ptr_end", - "references": [ - { - "ap_tracking_data": { - "group": 12, - "offset": 2 - }, - "pc": 195, - "value": "[cast(ap + (-1), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_chain.hash_chain.hash_loop": { - "pc": 197, - "type": "label" - }, - "starkware.cairo.common.hash_chain.hash_chain.hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "starkware.cairo.common.hash_chain.hash_chain.hash_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 12, - "offset": 0 - }, - "pc": 193, - "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 9 - }, - "pc": 208, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_chain.hash_chain.loop_frame": { - "cairo_type": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals", - "full_name": "starkware.cairo.common.hash_chain.hash_chain.loop_frame", - "references": [ - { - "ap_tracking_data": { - "group": 12, - "offset": 4 - }, - "pc": 197, - "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_chain.hash_chain.n_elements_to_hash", - "references": [ - { - "ap_tracking_data": { - "group": 12, - "offset": 5 - }, - "pc": 198, - "value": "[cast(ap, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_chain.hash_chain.new_data": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_chain.hash_chain.new_data", - "references": [ - { - "ap_tracking_data": { - "group": 12, - "offset": 5 - }, - "pc": 198, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_chain.hash_chain.next_frame": { - "cairo_type": "starkware.cairo.common.hash_chain.hash_chain.LoopLocals", - "full_name": "starkware.cairo.common.hash_chain.hash_chain.next_frame", - "references": [ - { - "ap_tracking_data": { - "group": 12, - "offset": 9 - }, - "pc": 205, - "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.HashBuiltin": { - "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", - "type": "alias" - }, - "starkware.cairo.common.hash_state.HashState": { - "full_name": "starkware.cairo.common.hash_state.HashState", - "members": { - "current_hash": { - "cairo_type": "felt", - "offset": 0 - }, - "n_words": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.hash_state.get_fp_and_pc": { - "destination": "starkware.cairo.common.registers.get_fp_and_pc", - "type": "alias" - }, - "starkware.cairo.common.hash_state.hash2": { - "destination": "starkware.cairo.common.hash.hash2", - "type": "alias" - }, - "starkware.cairo.common.hash_state.hash_felts": { - "decorators": [], - "pc": 512, - "type": "function" - }, - "starkware.cairo.common.hash_state.hash_felts.Args": { - "full_name": "starkware.cairo.common.hash_state.hash_felts.Args", - "members": { - "data": { - "cairo_type": "felt*", - "offset": 0 - }, - "length": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_felts.ImplicitArgs": { - "full_name": "starkware.cairo.common.hash_state.hash_felts.ImplicitArgs", - "members": { - "hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_felts.Return": { - "cairo_type": "(hash: felt)", - "type": "type_definition" - }, - "starkware.cairo.common.hash_state.hash_felts.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.hash_state.hash_felts.data": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.hash_state.hash_felts.data", - "references": [ - { - "ap_tracking_data": { - "group": 40, - "offset": 0 - }, - "pc": 512, - "value": "[cast(fp + (-4), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts.hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "starkware.cairo.common.hash_state.hash_felts.hash_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 40, - "offset": 0 - }, - "pc": 512, - "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 41, - "offset": 0 - }, - "pc": 520, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 41, - "offset": 9 - }, - "pc": 522, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr": { - "cairo_type": "starkware.cairo.common.hash_state.HashState*", - "full_name": "starkware.cairo.common.hash_state.hash_felts.hash_state_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 40, - "offset": 7 - }, - "pc": 514, - "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" - }, - { - "ap_tracking_data": { - "group": 41, - "offset": 0 - }, - "pc": 520, - "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts.length": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_state.hash_felts.length", - "references": [ - { - "ap_tracking_data": { - "group": 40, - "offset": 0 - }, - "pc": 512, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding": { - "decorators": [], - "pc": 487, - "type": "function" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.Args": { - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.Args", - "members": { - "data_length": { - "cairo_type": "felt", - "offset": 1 - }, - "data_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "initial_hash": { - "cairo_type": "felt", - "offset": 2 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.ImplicitArgs": { - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.ImplicitArgs", - "members": { - "hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals": { - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals", - "members": { - "cur_hash": { - "cairo_type": "felt", - "offset": 2 - }, - "data_ptr": { - "cairo_type": "felt*", - "offset": 0 - }, - "hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 1 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.Return": { - "cairo_type": "(hash: felt)", - "type": "type_definition" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.SIZEOF_LOCALS": { - "type": "const", - "value": 1 - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp51", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 2 - }, - "pc": 496, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.__temp52", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 7 - }, - "pc": 503, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.data_last_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 2 - }, - "pc": 497, - "value": "[cast(fp, felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.data_length", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 0 - }, - "pc": 487, - "value": "[cast(fp + (-4), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.data_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 0 - }, - "pc": 487, - "value": "[cast(fp + (-5), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.final_locals": { - "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.final_locals", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 10 - }, - "pc": 511, - "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals": { - "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.first_locals", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 2 - }, - "pc": 497, - "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_loop": { - "pc": 500, - "type": "label" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.hash_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 0 - }, - "pc": 487, - "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 10 - }, - "pc": 511, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.initial_hash", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 0 - }, - "pc": 487, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.n_remaining_elements", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 6 - }, - "pc": 501, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals": { - "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.next_locals", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 7 - }, - "pc": 504, - "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals": { - "cairo_type": "starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*", - "full_name": "starkware.cairo.common.hash_state.hash_felts_no_padding.prev_locals", - "references": [ - { - "ap_tracking_data": { - "group": 39, - "offset": 5 - }, - "pc": 500, - "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_finalize": { - "decorators": [], - "pc": 481, - "type": "function" - }, - "starkware.cairo.common.hash_state.hash_finalize.Args": { - "full_name": "starkware.cairo.common.hash_state.hash_finalize.Args", - "members": { - "hash_state_ptr": { - "cairo_type": "starkware.cairo.common.hash_state.HashState*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_finalize.ImplicitArgs": { - "full_name": "starkware.cairo.common.hash_state.hash_finalize.ImplicitArgs", - "members": { - "hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_finalize.Return": { - "cairo_type": "(hash: felt)", - "type": "type_definition" - }, - "starkware.cairo.common.hash_state.hash_finalize.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.hash_state.hash_finalize.hash": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_state.hash_finalize.hash", - "references": [ - { - "ap_tracking_data": { - "group": 38, - "offset": 7 - }, - "pc": 486, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_finalize.hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "starkware.cairo.common.hash_state.hash_finalize.hash_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 38, - "offset": 0 - }, - "pc": 481, - "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 38, - "offset": 7 - }, - "pc": 486, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr": { - "cairo_type": "starkware.cairo.common.hash_state.HashState*", - "full_name": "starkware.cairo.common.hash_state.hash_finalize.hash_state_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 38, - "offset": 0 - }, - "pc": 481, - "value": "[cast(fp + (-3), starkware.cairo.common.hash_state.HashState**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_init": { - "decorators": [], - "pc": 455, - "type": "function" - }, - "starkware.cairo.common.hash_state.hash_init.Args": { - "full_name": "starkware.cairo.common.hash_state.hash_init.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_init.ImplicitArgs": { - "full_name": "starkware.cairo.common.hash_state.hash_init.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_init.Return": { - "cairo_type": "(hash_state_ptr: starkware.cairo.common.hash_state.HashState*)", - "type": "type_definition" - }, - "starkware.cairo.common.hash_state.hash_init.SIZEOF_LOCALS": { - "type": "const", - "value": 2 - }, - "starkware.cairo.common.hash_state.hash_init.__fp__": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.hash_state.hash_init.__fp__", - "references": [ - { - "ap_tracking_data": { - "group": 35, - "offset": 4 - }, - "pc": 459, - "value": "[cast(ap + (-2), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_init.hash_state": { - "cairo_type": "starkware.cairo.common.hash_state.HashState", - "full_name": "starkware.cairo.common.hash_state.hash_init.hash_state", - "references": [ - { - "ap_tracking_data": { - "group": 35, - "offset": 4 - }, - "pc": 459, - "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_update": { - "decorators": [], - "pc": 465, - "type": "function" - }, - "starkware.cairo.common.hash_state.hash_update.Args": { - "full_name": "starkware.cairo.common.hash_state.hash_update.Args", - "members": { - "data_length": { - "cairo_type": "felt", - "offset": 2 - }, - "data_ptr": { - "cairo_type": "felt*", - "offset": 1 - }, - "hash_state_ptr": { - "cairo_type": "starkware.cairo.common.hash_state.HashState*", - "offset": 0 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_update.ImplicitArgs": { - "full_name": "starkware.cairo.common.hash_state.hash_update.ImplicitArgs", - "members": { - "hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.hash_state.hash_update.Return": { - "cairo_type": "(new_hash_state_ptr: starkware.cairo.common.hash_state.HashState*)", - "type": "type_definition" - }, - "starkware.cairo.common.hash_state.hash_update.SIZEOF_LOCALS": { - "type": "const", - "value": 2 - }, - "starkware.cairo.common.hash_state.hash_update.__fp__": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.hash_state.hash_update.__fp__", - "references": [ - { - "ap_tracking_data": { - "group": 37, - "offset": 2 - }, - "pc": 475, - "value": "[cast(ap + (-2), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_update.__temp50": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_state.hash_update.__temp50", - "references": [ - { - "ap_tracking_data": { - "group": 37, - "offset": 3 - }, - "pc": 477, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_update.data_length": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_state.hash_update.data_length", - "references": [ - { - "ap_tracking_data": { - "group": 36, - "offset": 0 - }, - "pc": 465, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_update.data_ptr": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.hash_state.hash_update.data_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 36, - "offset": 0 - }, - "pc": 465, - "value": "[cast(fp + (-4), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_update.hash": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.hash_state.hash_update.hash", - "references": [ - { - "ap_tracking_data": { - "group": 37, - "offset": 0 - }, - "pc": 473, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_update.hash_ptr": { - "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", - "full_name": "starkware.cairo.common.hash_state.hash_update.hash_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 36, - "offset": 0 - }, - "pc": 465, - "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 37, - "offset": 0 - }, - "pc": 473, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_update.hash_state_ptr": { - "cairo_type": "starkware.cairo.common.hash_state.HashState*", - "full_name": "starkware.cairo.common.hash_state.hash_update.hash_state_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 36, - "offset": 0 - }, - "pc": 465, - "value": "[cast(fp + (-5), starkware.cairo.common.hash_state.HashState**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.hash_state.hash_update.new_hash_state": { - "cairo_type": "starkware.cairo.common.hash_state.HashState", - "full_name": "starkware.cairo.common.hash_state.hash_update.new_hash_state", - "references": [ - { - "ap_tracking_data": { - "group": 37, - "offset": 2 - }, - "pc": 475, - "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.keccak_state.KeccakBuiltinState": { - "full_name": "starkware.cairo.common.keccak_state.KeccakBuiltinState", - "members": { - "s0": { - "cairo_type": "felt", - "offset": 0 - }, - "s1": { - "cairo_type": "felt", - "offset": 1 - }, - "s2": { - "cairo_type": "felt", - "offset": 2 - }, - "s3": { - "cairo_type": "felt", - "offset": 3 - }, - "s4": { - "cairo_type": "felt", - "offset": 4 - }, - "s5": { - "cairo_type": "felt", - "offset": 5 - }, - "s6": { - "cairo_type": "felt", - "offset": 6 - }, - "s7": { - "cairo_type": "felt", - "offset": 7 - } - }, - "size": 8, - "type": "struct" - }, - "starkware.cairo.common.math.FALSE": { - "destination": "starkware.cairo.common.bool.FALSE", - "type": "alias" - }, - "starkware.cairo.common.math.TRUE": { - "destination": "starkware.cairo.common.bool.TRUE", - "type": "alias" - }, - "starkware.cairo.common.math.assert_le": { - "decorators": [], - "pc": 421, - "type": "function" - }, - "starkware.cairo.common.math.assert_le.Args": { - "full_name": "starkware.cairo.common.math.assert_le.Args", - "members": { - "a": { - "cairo_type": "felt", - "offset": 0 - }, - "b": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.math.assert_le.ImplicitArgs": { - "full_name": "starkware.cairo.common.math.assert_le.ImplicitArgs", - "members": { - "range_check_ptr": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.math.assert_le.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.common.math.assert_le.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.math.assert_le.a": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_le.a", - "references": [ - { - "ap_tracking_data": { - "group": 31, - "offset": 0 - }, - "pc": 421, - "value": "[cast(fp + (-4), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_le.b": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_le.b", - "references": [ - { - "ap_tracking_data": { - "group": 31, - "offset": 0 - }, - "pc": 421, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_le.range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_le.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 31, - "offset": 0 - }, - "pc": 421, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 31, - "offset": 5 - }, - "pc": 425, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_nn": { - "decorators": [], - "pc": 417, - "type": "function" - }, - "starkware.cairo.common.math.assert_nn.Args": { - "full_name": "starkware.cairo.common.math.assert_nn.Args", - "members": { - "a": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.math.assert_nn.ImplicitArgs": { - "full_name": "starkware.cairo.common.math.assert_nn.ImplicitArgs", - "members": { - "range_check_ptr": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.math.assert_nn.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.common.math.assert_nn.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.math.assert_nn.a": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_nn.a", - "references": [ - { - "ap_tracking_data": { - "group": 30, - "offset": 0 - }, - "pc": 417, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_nn.range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_nn.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 30, - "offset": 0 - }, - "pc": 417, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 30, - "offset": 0 - }, - "pc": 418, - "value": "cast([fp + (-4)] + 1, felt)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_nn_le": { - "decorators": [], - "pc": 426, - "type": "function" - }, - "starkware.cairo.common.math.assert_nn_le.Args": { - "full_name": "starkware.cairo.common.math.assert_nn_le.Args", - "members": { - "a": { - "cairo_type": "felt", - "offset": 0 - }, - "b": { - "cairo_type": "felt", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.math.assert_nn_le.ImplicitArgs": { - "full_name": "starkware.cairo.common.math.assert_nn_le.ImplicitArgs", - "members": { - "range_check_ptr": { - "cairo_type": "felt", - "offset": 0 - } - }, - "size": 1, - "type": "struct" - }, - "starkware.cairo.common.math.assert_nn_le.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.common.math.assert_nn_le.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.math.assert_nn_le.a": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_nn_le.a", - "references": [ - { - "ap_tracking_data": { - "group": 32, - "offset": 0 - }, - "pc": 426, - "value": "[cast(fp + (-4), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_nn_le.b": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_nn_le.b", - "references": [ - { - "ap_tracking_data": { - "group": 32, - "offset": 0 - }, - "pc": 426, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.math.assert_nn_le.range_check_ptr": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.math.assert_nn_le.range_check_ptr", - "references": [ - { - "ap_tracking_data": { - "group": 32, - "offset": 0 - }, - "pc": 426, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 32, - "offset": 5 - }, - "pc": 430, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 32, - "offset": 14 - }, - "pc": 434, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.memcpy.memcpy": { - "decorators": [], - "pc": 523, - "type": "function" - }, - "starkware.cairo.common.memcpy.memcpy.Args": { - "full_name": "starkware.cairo.common.memcpy.memcpy.Args", - "members": { - "dst": { - "cairo_type": "felt*", - "offset": 0 - }, - "len": { - "cairo_type": "felt", - "offset": 2 - }, - "src": { - "cairo_type": "felt*", - "offset": 1 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.memcpy.memcpy.ImplicitArgs": { - "full_name": "starkware.cairo.common.memcpy.memcpy.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.common.memcpy.memcpy.LoopFrame": { - "full_name": "starkware.cairo.common.memcpy.memcpy.LoopFrame", - "members": { - "dst": { - "cairo_type": "felt*", - "offset": 0 - }, - "src": { - "cairo_type": "felt*", - "offset": 1 - } - }, - "size": 2, - "type": "struct" - }, - "starkware.cairo.common.memcpy.memcpy.Return": { - "cairo_type": "()", - "type": "type_definition" - }, - "starkware.cairo.common.memcpy.memcpy.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.common.memcpy.memcpy.__temp53": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.memcpy.memcpy.__temp53", - "references": [ - { - "ap_tracking_data": { - "group": 42, - "offset": 3 - }, - "pc": 529, - "value": "[cast(ap + (-1), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.memcpy.memcpy.continue_copying": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.memcpy.memcpy.continue_copying", - "references": [ - { - "ap_tracking_data": { - "group": 42, - "offset": 3 - }, - "pc": 530, - "value": "[cast(ap, felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.memcpy.memcpy.dst": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.memcpy.memcpy.dst", - "references": [ - { - "ap_tracking_data": { - "group": 42, - "offset": 0 - }, - "pc": 523, - "value": "[cast(fp + (-5), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.memcpy.memcpy.frame": { - "cairo_type": "starkware.cairo.common.memcpy.memcpy.LoopFrame", - "full_name": "starkware.cairo.common.memcpy.memcpy.frame", - "references": [ - { - "ap_tracking_data": { - "group": 42, - "offset": 2 - }, - "pc": 528, - "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" - }, - { - "ap_tracking_data": { - "group": 42, - "offset": 2 - }, - "pc": 528, - "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.memcpy.memcpy.len": { - "cairo_type": "felt", - "full_name": "starkware.cairo.common.memcpy.memcpy.len", - "references": [ - { - "ap_tracking_data": { - "group": 42, - "offset": 0 - }, - "pc": 523, - "value": "[cast(fp + (-3), felt*)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.memcpy.memcpy.loop": { - "pc": 528, - "type": "label" - }, - "starkware.cairo.common.memcpy.memcpy.next_frame": { - "cairo_type": "starkware.cairo.common.memcpy.memcpy.LoopFrame*", - "full_name": "starkware.cairo.common.memcpy.memcpy.next_frame", - "references": [ - { - "ap_tracking_data": { - "group": 42, - "offset": 3 - }, - "pc": 530, - "value": "cast(ap + 1, starkware.cairo.common.memcpy.memcpy.LoopFrame*)" - } - ], - "type": "reference" - }, - "starkware.cairo.common.memcpy.memcpy.src": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.common.memcpy.memcpy.src", - "references": [ - { - "ap_tracking_data": { - "group": 42, - "offset": 0 - }, - "pc": 523, - "value": "[cast(fp + (-4), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.common.poseidon_state.PoseidonBuiltinState": { - "full_name": "starkware.cairo.common.poseidon_state.PoseidonBuiltinState", - "members": { - "s0": { - "cairo_type": "felt", - "offset": 0 - }, - "s1": { - "cairo_type": "felt", - "offset": 1 - }, - "s2": { - "cairo_type": "felt", - "offset": 2 - } - }, - "size": 3, - "type": "struct" - }, - "starkware.cairo.common.registers.get_ap": { - "destination": "starkware.cairo.lang.compiler.lib.registers.get_ap", - "type": "alias" - }, - "starkware.cairo.common.registers.get_fp_and_pc": { - "destination": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc", - "type": "alias" - }, - "starkware.cairo.lang.compiler.lib.registers.get_ap": { - "decorators": [ - "known_ap_change" - ], - "pc": 1, - "type": "function" - }, - "starkware.cairo.lang.compiler.lib.registers.get_ap.Args": { - "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.lang.compiler.lib.registers.get_ap.ImplicitArgs": { - "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.lang.compiler.lib.registers.get_ap.Return": { - "cairo_type": "(ap_val: felt*)", - "type": "type_definition" - }, - "starkware.cairo.lang.compiler.lib.registers.get_ap.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - }, - "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.fp_val", - "references": [ - { - "ap_tracking_data": { - "group": 1, - "offset": 2 - }, - "pc": 3, - "value": "[cast(ap + (-2), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val": { - "cairo_type": "felt*", - "full_name": "starkware.cairo.lang.compiler.lib.registers.get_ap.pc_val", - "references": [ - { - "ap_tracking_data": { - "group": 1, - "offset": 2 - }, - "pc": 3, - "value": "[cast(ap + (-1), felt**)]" - } - ], - "type": "reference" - }, - "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc": { - "decorators": [], - "pc": 0, - "type": "function" - }, - "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Args": { - "full_name": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Args", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.ImplicitArgs": { - "full_name": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.ImplicitArgs", - "members": {}, - "size": 0, - "type": "struct" - }, - "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Return": { - "cairo_type": "(fp_val: felt*, pc_val: felt*)", - "type": "type_definition" - }, - "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.SIZEOF_LOCALS": { - "type": "const", - "value": 0 - } - }, - "main_scope": "__main__", - "prime": "0x800000000000011000000000000000000000000000000000000000000000001", - "reference_manager": { - "references": [ - { - "ap_tracking_data": { - "group": 1, - "offset": 2 - }, - "pc": 3, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 1, - "offset": 2 - }, - "pc": 3, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 2, - "offset": 0 - }, - "pc": 6, - "value": "[cast(fp + (-7), felt**)]" - }, - { - "ap_tracking_data": { - "group": 2, - "offset": 0 - }, - "pc": 6, - "value": "[cast(fp + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 2, - "offset": 0 - }, - "pc": 6, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { - "group": 2, - "offset": 0 - }, - "pc": 6, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 2, - "offset": 0 - }, - "pc": 6, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 2, - "offset": 3 - }, - "pc": 12, - "value": "[cast(fp, felt*)]" - }, - { - "ap_tracking_data": { - "group": 2, - "offset": 3 - }, - "pc": 14, - "value": "[cast(fp + 1, felt*)]" - }, - { - "ap_tracking_data": { - "group": 2, - "offset": 3 - }, - "pc": 15, - "value": "[cast(fp + 2, felt*)]" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "[cast(fp + (-7), felt**)]" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "[cast(fp + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "cast([fp + (-5)] * 10 + 1, felt)" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 0 - }, - "pc": 32, - "value": "cast([fp + (-5)] * 10 + 12, felt)" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 2 - }, - "pc": 34, - "value": "[cast(ap + (-2), (fp_val: felt*, pc_val: felt*)*)]" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 2 - }, - "pc": 34, - "value": "cast([ap + (-2)] + [fp + (-5)] * 10 + 12, felt*)" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 3 - }, - "pc": 36, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 4, - "offset": 4 - }, - "pc": 38, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 5, - "offset": 0 - }, - "pc": 45, - "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" - }, - { - "ap_tracking_data": { - "group": 7, - "offset": 0 - }, - "pc": 48, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { - "group": 7, - "offset": 0 - }, - "pc": 48, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 7, - "offset": 0 - }, - "pc": 48, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 7, - "offset": 0 - }, - "pc": 48, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 7, - "offset": 1 - }, - "pc": 49, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 7, - "offset": 2 - }, - "pc": 50, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 7, - "offset": 2 - }, - "pc": 51, - "value": "cast([fp + (-6)] + 1, felt)" - }, - { - "ap_tracking_data": { - "group": 8, - "offset": 0 - }, - "pc": 54, - "value": "[cast(fp + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 8, - "offset": 0 - }, - "pc": 54, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { - "group": 8, - "offset": 0 - }, - "pc": 54, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 8, - "offset": 0 - }, - "pc": 54, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 8, - "offset": 0 - }, - "pc": 54, - "value": "[cast(fp + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 8, - "offset": 9 - }, - "pc": 64, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 9, - "offset": 0 - }, - "pc": 74, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 0 - }, - "pc": 75, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 0 - }, - "pc": 75, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 0 - }, - "pc": 75, - "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 0 - }, - "pc": 75, - "value": "cast([fp + (-3)] + [fp + (-4)], felt*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 3 - }, - "pc": 81, - "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 4 - }, - "pc": 82, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 5 - }, - "pc": 83, - "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 6 - }, - "pc": 85, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 7 - }, - "pc": 90, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 8 - }, - "pc": 91, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 9 - }, - "pc": 93, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 94, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 96, - "value": "[cast([ap + (-6)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 96, - "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 11 - }, - "pc": 97, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 12 - }, - "pc": 98, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 13 - }, - "pc": 99, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 14 - }, - "pc": 101, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 15 - }, - "pc": 102, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 16 - }, - "pc": 103, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 17 - }, - "pc": 105, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 17 - }, - "pc": 106, - "value": "[cast([ap + (-13)] + 9, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 17 - }, - "pc": 106, - "value": "cast([ap + (-13)] + 12, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 18 - }, - "pc": 107, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 19 - }, - "pc": 108, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 20 - }, - "pc": 109, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 21 - }, - "pc": 111, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 22 - }, - "pc": 112, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 23 - }, - "pc": 113, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 24 - }, - "pc": 115, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 24 - }, - "pc": 116, - "value": "[cast([ap + (-20)] + 15, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 24 - }, - "pc": 116, - "value": "cast([ap + (-20)] + 18, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 25 - }, - "pc": 117, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 26 - }, - "pc": 118, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 27 - }, - "pc": 119, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 28 - }, - "pc": 121, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 29 - }, - "pc": 122, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 30 - }, - "pc": 123, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 31 - }, - "pc": 125, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 31 - }, - "pc": 126, - "value": "[cast([ap + (-27)] + 21, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 31 - }, - "pc": 126, - "value": "cast([ap + (-27)] + 24, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 32 - }, - "pc": 127, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 33 - }, - "pc": 128, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 34 - }, - "pc": 129, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 35 - }, - "pc": 131, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 36 - }, - "pc": 132, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 37 - }, - "pc": 133, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 38 - }, - "pc": 135, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 38 - }, - "pc": 136, - "value": "[cast([ap + (-34)] + 27, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 38 - }, - "pc": 136, - "value": "cast([ap + (-34)] + 30, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 41 - }, - "pc": 139, - "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 42 - }, - "pc": 141, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 43 - }, - "pc": 143, - "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 7 - }, - "pc": 147, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 8 - }, - "pc": 152, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 9 - }, - "pc": 153, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 155, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 11 - }, - "pc": 156, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 11 - }, - "pc": 158, - "value": "[cast([ap + (-7)] + 3, starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 11 - }, - "pc": 158, - "value": "cast([ap + (-7)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 14 - }, - "pc": 161, - "value": "[cast(ap + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 15 - }, - "pc": 163, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 16 - }, - "pc": 165, - "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 11, - "offset": 0 - }, - "pc": 141, - "value": "[cast(ap - 1 + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 11, - "offset": 0 - }, - "pc": 143, - "value": "[cast(ap - 0 + (-1), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 11, - "offset": 0 - }, - "pc": 139, - "value": "[cast(ap - 2 + (-3), starkware.cairo.common.poseidon_state.PoseidonBuiltinState*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 8 - }, - "pc": 168, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 9 - }, - "pc": 169, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 173, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 176, - "value": "[cast([ap + (-6)] + 3, felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 176, - "value": "cast([ap + (-6)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 10 - }, - "pc": 183, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 11 - }, - "pc": 184, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 12 - }, - "pc": 187, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 12 - }, - "pc": 189, - "value": "[cast([ap + (-8)] + 3, felt*)]" - }, - { - "ap_tracking_data": { - "group": 10, - "offset": 12 - }, - "pc": 189, - "value": "cast([ap + (-8)] + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 0 - }, - "pc": 193, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 0 - }, - "pc": 193, - "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 1 - }, - "pc": 194, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 2 - }, - "pc": 195, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 4 - }, - "pc": 197, - "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 4 - }, - "pc": 197, - "value": "cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 4 - }, - "pc": 197, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 5 - }, - "pc": 198, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 5 - }, - "pc": 198, - "value": "[cast(ap, felt*)]" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 9 - }, - "pc": 205, - "value": "[cast(ap + (-3), starkware.cairo.common.hash_chain.hash_chain.LoopLocals*)]" - }, - { - "ap_tracking_data": { - "group": 12, - "offset": 9 - }, - "pc": 208, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 13, - "offset": 0 - }, - "pc": 209, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 13, - "offset": 0 - }, - "pc": 209, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 13, - "offset": 0 - }, - "pc": 209, - "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 13, - "offset": 0 - }, - "pc": 209, - "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 13, - "offset": 1 - }, - "pc": 211, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 14, - "offset": 0 - }, - "pc": 219, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 14, - "offset": 0 - }, - "pc": 219, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 15, - "offset": 0 - }, - "pc": 227, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 15, - "offset": 0 - }, - "pc": 227, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 0 - }, - "pc": 231, - "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 0 - }, - "pc": 231, - "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 0 - }, - "pc": 231, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 0 - }, - "pc": 231, - "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 0 - }, - "pc": 231, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 235, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 236, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 236, - "value": "[cast(fp + 1, felt**)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 236, - "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 237, - "value": "[cast(fp + 2, felt*)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 28 - }, - "pc": 237, - "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.ProgramHeader**)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 29 - }, - "pc": 239, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 29 - }, - "pc": 240, - "value": "[cast([fp + (-7)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 16, - "offset": 29 - }, - "pc": 240, - "value": "[cast([fp + (-7)] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 0 - }, - "pc": 246, - "value": "[cast(ap + (-3), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 0 - }, - "pc": 246, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 0 - }, - "pc": 246, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 0 - }, - "pc": 249, - "value": "[cast(fp + 3, felt**)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 0 - }, - "pc": 250, - "value": "[cast(fp + 4, felt*)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 1 - }, - "pc": 251, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 2 - }, - "pc": 252, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 2 - }, - "pc": 253, - "value": "[cast(fp + 5, felt**)]" - }, - { - "ap_tracking_data": { - "group": 17, - "offset": 2 - }, - "pc": 263, - "value": "[cast(fp + 6, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" - }, - { - "ap_tracking_data": { - "group": 19, - "offset": 5 - }, - "pc": 275, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 19, - "offset": 5 - }, - "pc": 276, - "value": "[cast(fp + 15, felt**)]" - }, - { - "ap_tracking_data": { - "group": 19, - "offset": 5 - }, - "pc": 276, - "value": "[cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" - }, - { - "ap_tracking_data": { - "group": 20, - "offset": 0 - }, - "pc": 285, - "value": "[cast(ap + (-1), (selected_encodings_end: felt*)*)]" - }, - { - "ap_tracking_data": { - "group": 21, - "offset": 0 - }, - "pc": 296, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 21, - "offset": 0 - }, - "pc": 297, - "value": "[cast(fp + 25, felt*)]" - }, - { - "ap_tracking_data": { - "group": 21, - "offset": 0 - }, - "pc": 298, - "value": "cast(fp + 16, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-11), felt**)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-9), felt*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-8), felt*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 0 - }, - "pc": 302, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 304, - "value": "[cast(fp, felt*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 304, - "value": "[cast([fp + (-11)], felt*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 304, - "value": "cast([fp + (-11)] + 1, felt*)" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 314, - "value": "[cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 332, - "value": "[cast(fp + 10, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 29 - }, - "pc": 350, - "value": "[cast(fp + 19, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 31 - }, - "pc": 352, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 31 - }, - "pc": 352, - "value": "cast(fp + 1, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData*)" - }, - { - "ap_tracking_data": { - "group": 22, - "offset": 31 - }, - "pc": 352, - "value": "[cast(fp + (-9), felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 362, - "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 362, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast(fp + 28, starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28], felt**)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 2, felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 3, felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 4, felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 5, felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 6, felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 7, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "[cast([fp + 28] + 8, felt*)]" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 0 - }, - "pc": 364, - "value": "cast([[fp + 28] + 2] - [ap + (-1)], felt)" - }, - { - "ap_tracking_data": { - "group": 23, - "offset": 1 - }, - "pc": 365, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 25, - "offset": 0 - }, - "pc": 380, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 25, - "offset": 0 - }, - "pc": 380, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 25, - "offset": 1 - }, - "pc": 387, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 25, - "offset": 2 - }, - "pc": 388, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 25, - "offset": 3 - }, - "pc": 389, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 27, - "offset": 0 - }, - "pc": 396, - "value": "[cast(fp + (-5), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 27, - "offset": 0 - }, - "pc": 396, - "value": "[cast(fp + (-4), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 27, - "offset": 0 - }, - "pc": 396, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 27, - "offset": 0 - }, - "pc": 396, - "value": "[cast(fp + (-7), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 27, - "offset": 0 - }, - "pc": 396, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 27, - "offset": 1 - }, - "pc": 403, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 28, - "offset": 0 - }, - "pc": 410, - "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 28, - "offset": 0 - }, - "pc": 410, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 29, - "offset": 0 - }, - "pc": 416, - "value": "[cast(ap + (-2), starkware.cairo.bootloaders.simple_bootloader.execute_task.BuiltinData**)]" - }, - { - "ap_tracking_data": { - "group": 29, - "offset": 0 - }, - "pc": 416, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 30, - "offset": 0 - }, - "pc": 417, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 30, - "offset": 0 - }, - "pc": 417, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 30, - "offset": 0 - }, - "pc": 418, - "value": "cast([fp + (-4)] + 1, felt)" - }, - { - "ap_tracking_data": { - "group": 31, - "offset": 0 - }, - "pc": 421, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 31, - "offset": 0 - }, - "pc": 421, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 31, - "offset": 0 - }, - "pc": 421, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 31, - "offset": 5 - }, - "pc": 425, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 32, - "offset": 0 - }, - "pc": 426, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 32, - "offset": 0 - }, - "pc": 426, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 32, - "offset": 0 - }, - "pc": 426, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 32, - "offset": 5 - }, - "pc": 430, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 32, - "offset": 14 - }, - "pc": 434, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 33, - "offset": 0 - }, - "pc": 435, - "value": "[cast(fp + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 33, - "offset": 0 - }, - "pc": 435, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 33, - "offset": 0 - }, - "pc": 435, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 33, - "offset": 0 - }, - "pc": 435, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 33, - "offset": 0 - }, - "pc": 435, - "value": "[cast(fp + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 33, - "offset": 1 - }, - "pc": 437, - "value": "[cast(fp, felt*)]" - }, - { - "ap_tracking_data": { - "group": 33, - "offset": 20 - }, - "pc": 443, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 33, - "offset": 21 - }, - "pc": 444, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 33, - "offset": 22 - }, - "pc": 445, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 34, - "offset": 0 - }, - "pc": 449, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 34, - "offset": 0 - }, - "pc": 449, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 34, - "offset": 0 - }, - "pc": 449, - "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 34, - "offset": 0 - }, - "pc": 451, - "value": "[cast([fp + (-5)] + 2, felt*)]" - }, - { - "ap_tracking_data": { - "group": 34, - "offset": 0 - }, - "pc": 451, - "value": "cast([fp + (-5)] + 3, starkware.cairo.common.cairo_builtins.HashBuiltin*)" - }, - { - "ap_tracking_data": { - "group": 35, - "offset": 4 - }, - "pc": 459, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 35, - "offset": 4 - }, - "pc": 459, - "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" - }, - { - "ap_tracking_data": { - "group": 36, - "offset": 0 - }, - "pc": 465, - "value": "[cast(fp + (-5), starkware.cairo.common.hash_state.HashState**)]" - }, - { - "ap_tracking_data": { - "group": 36, - "offset": 0 - }, - "pc": 465, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 36, - "offset": 0 - }, - "pc": 465, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 36, - "offset": 0 - }, - "pc": 465, - "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 37, - "offset": 0 - }, - "pc": 473, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 37, - "offset": 0 - }, - "pc": 473, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 37, - "offset": 2 - }, - "pc": 475, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 37, - "offset": 2 - }, - "pc": 475, - "value": "[cast(fp, starkware.cairo.common.hash_state.HashState*)]" - }, - { - "ap_tracking_data": { - "group": 37, - "offset": 3 - }, - "pc": 477, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 38, - "offset": 0 - }, - "pc": 481, - "value": "[cast(fp + (-3), starkware.cairo.common.hash_state.HashState**)]" - }, - { - "ap_tracking_data": { - "group": 38, - "offset": 0 - }, - "pc": 481, - "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 38, - "offset": 7 - }, - "pc": 486, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 38, - "offset": 7 - }, - "pc": 486, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 0 - }, - "pc": 487, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 0 - }, - "pc": 487, - "value": "[cast(fp + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 0 - }, - "pc": 487, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 0 - }, - "pc": 487, - "value": "[cast(fp + (-6), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 2 - }, - "pc": 496, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 2 - }, - "pc": 497, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 2 - }, - "pc": 497, - "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 5 - }, - "pc": 500, - "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 6 - }, - "pc": 501, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 7 - }, - "pc": 503, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 7 - }, - "pc": 504, - "value": "cast(ap, starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 10 - }, - "pc": 511, - "value": "cast(ap + (-3), starkware.cairo.common.hash_state.hash_felts_no_padding.LoopLocals*)" - }, - { - "ap_tracking_data": { - "group": 39, - "offset": 10 - }, - "pc": 511, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 40, - "offset": 0 - }, - "pc": 512, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 40, - "offset": 0 - }, - "pc": 512, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 40, - "offset": 0 - }, - "pc": 512, - "value": "[cast(fp + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 40, - "offset": 7 - }, - "pc": 514, - "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" - }, - { - "ap_tracking_data": { - "group": 41, - "offset": 0 - }, - "pc": 520, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 41, - "offset": 0 - }, - "pc": 520, - "value": "[cast(ap + (-1), starkware.cairo.common.hash_state.HashState**)]" - }, - { - "ap_tracking_data": { - "group": 41, - "offset": 9 - }, - "pc": 522, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 42, - "offset": 0 - }, - "pc": 523, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { - "group": 42, - "offset": 0 - }, - "pc": 523, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 42, - "offset": 0 - }, - "pc": 523, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 42, - "offset": 2 - }, - "pc": 528, - "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" - }, - { - "ap_tracking_data": { - "group": 42, - "offset": 2 - }, - "pc": 528, - "value": "[cast(ap + (-2), starkware.cairo.common.memcpy.memcpy.LoopFrame*)]" - }, - { - "ap_tracking_data": { - "group": 42, - "offset": 3 - }, - "pc": 529, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 42, - "offset": 3 - }, - "pc": 530, - "value": "[cast(ap, felt*)]" - }, - { - "ap_tracking_data": { - "group": 42, - "offset": 3 - }, - "pc": 530, - "value": "cast(ap + 1, starkware.cairo.common.memcpy.memcpy.LoopFrame*)" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-11), felt**)]" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-10), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-9), felt*)]" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-8), felt*)]" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 0 - }, - "pc": 538, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 11 - }, - "pc": 540, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 43, - "offset": 11 - }, - "pc": 540, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-9), felt**)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-4), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 551, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 552, - "value": "[cast(fp + 1, felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 553, - "value": "[cast(fp + 2, felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 554, - "value": "[cast(fp + 3, felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 555, - "value": "[cast(fp + 4, felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 556, - "value": "[cast(fp + 5, felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 557, - "value": "[cast(fp + 6, starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 558, - "value": "[cast(fp + 7, felt*)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 559, - "value": "[cast(fp + 8, felt**)]" - }, - { - "ap_tracking_data": { - "group": 44, - "offset": 0 - }, - "pc": 559, - "value": "[cast(fp + 9, __main__.BootloaderConfig**)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 564, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 564, - "value": "[cast(ap + (-1), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "[cast(fp + 10, felt**)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "cast([ap + (-2)] + 1, felt*)" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "[cast([fp], felt*)]" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "cast([fp] + 1, felt*)" - }, - { - "ap_tracking_data": { - "group": 45, - "offset": 0 - }, - "pc": 565, - "value": "cast(0, felt)" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-2), felt*)]" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 46, - "offset": 0 - }, - "pc": 578, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-4), __main__.BootloaderConfig**)]" - }, - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-10), felt**)]" - }, - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-9), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-7), felt*)]" - }, - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 47, - "offset": 0 - }, - "pc": 590, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { - "group": 47, - "offset": 1 - }, - "pc": 603, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-2), felt*)]" - }, - { - "ap_tracking_data": { - "group": 48, - "offset": 0 - }, - "pc": 614, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-2), felt*)]" - }, - { - "ap_tracking_data": { - "group": 49, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 50, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap - 0 + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 50, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap - 0 + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 50, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap - 0 + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 50, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap - 0 + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 50, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap - 0 + (-2), felt*)]" - }, - { - "ap_tracking_data": { - "group": 50, - "offset": 0 - }, - "pc": 625, - "value": "[cast(ap - 0 + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-2), felt*)]" - }, - { - "ap_tracking_data": { - "group": 51, - "offset": 0 - }, - "pc": 630, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 52, - "offset": 0 - }, - "pc": 631, - "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" - }, - { - "ap_tracking_data": { - "group": 52, - "offset": 0 - }, - "pc": 631, - "value": "[cast(fp + (-5), felt**)]" - }, - { - "ap_tracking_data": { - "group": 52, - "offset": 0 - }, - "pc": 631, - "value": "[cast(fp + (-4), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 52, - "offset": 1 - }, - "pc": 632, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 53, - "offset": 0 - }, - "pc": 638, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 53, - "offset": 0 - }, - "pc": 638, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 53, - "offset": 0 - }, - "pc": 639, - "value": "cast([fp + (-5)] + 2, felt*)" - }, - { - "ap_tracking_data": { - "group": 54, - "offset": 0 - }, - "pc": 643, - "value": "[cast(fp + (-3), felt**)]" - }, - { - "ap_tracking_data": { - "group": 54, - "offset": 0 - }, - "pc": 643, - "value": "[cast(fp + (-3), __main__.TaskOutputHeader**)]" - }, - { - "ap_tracking_data": { - "group": 54, - "offset": 0 - }, - "pc": 643, - "value": "cast([fp + (-3)] + 2, felt*)" - }, - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" - }, - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-9), felt**)]" - }, - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 55, - "offset": 0 - }, - "pc": 647, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 55, - "offset": 4 - }, - "pc": 649, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 55, - "offset": 4 - }, - "pc": 649, - "value": "[cast(fp + 1, felt*)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 0 - }, - "pc": 654, - "value": "[cast(ap + (-2), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 0 - }, - "pc": 654, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 5 - }, - "pc": 657, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 5 - }, - "pc": 657, - "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 6 - }, - "pc": 659, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 37 - }, - "pc": 668, - "value": "[cast(ap + (-2), felt*)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 38 - }, - "pc": 669, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 38 - }, - "pc": 673, - "value": "[cast(fp + 2, felt**)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 38 - }, - "pc": 674, - "value": "[cast(fp + 3, felt**)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 38 - }, - "pc": 674, - "value": "[cast([fp], felt*)]" - }, - { - "ap_tracking_data": { - "group": 56, - "offset": 38 - }, - "pc": 674, - "value": "cast([fp] + 1, felt*)" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-6), felt**)]" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-5), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-4), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-3), felt*)]" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-2), felt*)]" - }, - { - "ap_tracking_data": { - "group": 57, - "offset": 0 - }, - "pc": 685, - "value": "[cast(ap + (-1), felt**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-3), __main__.BootloaderConfig**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-9), felt**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-8), starkware.cairo.common.cairo_builtins.HashBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-7), starkware.cairo.common.cairo_builtins.PoseidonBuiltin**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-6), felt*)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-5), felt*)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 0 - }, - "pc": 693, - "value": "[cast(fp + (-4), felt**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 7 - }, - "pc": 698, - "value": "[cast(ap + (-2), felt**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 7 - }, - "pc": 698, - "value": "[cast(ap + (-1), __main__.TaskOutputHeader**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 7 - }, - "pc": 699, - "value": "[cast(fp, felt**)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 8 - }, - "pc": 700, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 9 - }, - "pc": 702, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 9 - }, - "pc": 703, - "value": "cast([fp + (-9)] + 2, felt*)" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 10 - }, - "pc": 704, - "value": "[cast(ap + (-1), felt*)]" - }, - { - "ap_tracking_data": { - "group": 58, - "offset": 10 - }, - "pc": 706, - "value": "[cast(fp + 1, felt*)]" - }, - { - "ap_tracking_data": { - "group": 59, - "offset": 0 - }, - "pc": 712, - "value": "cast([fp + (-9)] + 2 + [fp + 1], felt*)" - }, - { - "ap_tracking_data": { - "group": 59, - "offset": 0 - }, - "pc": 712, - "value": "cast([fp] + [fp + 1], felt*)" - }, - { - "ap_tracking_data": { - "group": 59, - "offset": 0 - }, - "pc": 712, - "value": "cast([fp + (-5)] + 1, felt)" - }, - { - "ap_tracking_data": { - "group": 59, - "offset": 1 - }, - "pc": 714, - "value": "[cast(ap + (-1), felt*)]" - } - ] - } -} diff --git a/scripts/compile-bootloader.sh b/scripts/compile-bootloader.sh index ada0b76..2010cc3 100644 --- a/scripts/compile-bootloader.sh +++ b/scripts/compile-bootloader.sh @@ -4,7 +4,7 @@ # to recompile the bootloader when changing the version of cairo-lang. SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd ) -CAIRO_VERSION="0.13.1" +CAIRO_VERSION="0.13.0" CAIRO_LANG_DIR=$(readlink -f "${SCRIPT_DIR}/../dependencies/cairo-lang") @@ -27,6 +27,10 @@ OUTPUT_DIR="$(readlink -f "${SCRIPT_DIR}/../resources")" mkdir -p "${OUTPUT_DIR}" COMPILED_BOOTLOADER="${OUTPUT_DIR}/bootloader-${CAIRO_VERSION}.json" -cairo-compile "${CAIRO_LANG_DIR}/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" --output "${COMPILED_BOOTLOADER}" --cairo_path "${CAIRO_LANG_DIR}"/src +cairo-compile \ + "${CAIRO_LANG_DIR}/src/starkware/cairo/bootloaders/bootloader/bootloader.cairo" \ + --output "${COMPILED_BOOTLOADER}" \ + --cairo_path "${CAIRO_LANG_DIR}"/src \ + --proof_mode echo "Compiled the bootloader to '${COMPILED_BOOTLOADER}'." \ No newline at end of file diff --git a/src/hints/bootloader_hints.rs b/src/hints/bootloader_hints.rs index daed1f1..f71f2ea 100644 --- a/src/hints/bootloader_hints.rs +++ b/src/hints/bootloader_hints.rs @@ -452,7 +452,7 @@ mod tests { use cairo_vm::vm::runners::builtin_runner::{ BuiltinRunner, OutputBuiltinRunner, OutputBuiltinState, }; - use cairo_vm::vm::runners::cairo_pie::PublicMemoryPage; + use cairo_vm::vm::runners::cairo_pie::{BuiltinAdditionalData, PublicMemoryPage}; use cairo_vm::{any_box, relocatable, Felt252}; use rstest::{fixture, rstest}; @@ -568,8 +568,14 @@ mod tests { fn test_restore_bootloader_output() { let mut vm: VirtualMachine = vm!(); // The VM must have an existing output segment - vm.add_memory_segment(); - vm.builtin_runners = vec![OutputBuiltinRunner::new(true).into()]; + let output_segment = vm.add_memory_segment(); + let output_builtin = { + let mut builtin = OutputBuiltinRunner::new(true); + builtin.new_state(output_segment.segment_index.try_into().unwrap(), true); + builtin + }; + + vm.builtin_runners = vec![output_builtin.into()]; let mut exec_scopes = ExecutionScopes::new(); let new_segment = vm.add_memory_segment(); @@ -690,7 +696,6 @@ mod tests { // Set n_subtasks to 2 vm.set_fp(1); define_segments!(vm, 2, [((1, 0), 2)]); - // let ids_data = ids_data!["n_subtasks"]; let ids_data = HashMap::from([("n_subtasks".to_string(), HintReference::new_simple(-1))]); let ap_tracking = ApTracking::default(); @@ -742,8 +747,8 @@ mod tests { assert!(is_plain(&mut vm, &mut exec_scopes, plain_packed_output)); // Increment AP to avoid an inconsistent memory error writing in the same slot - let new_ap = (*&vm.get_ap() + 1usize).unwrap(); - vm.set_ap(new_ap.offset); + let new_ap = &vm.get_ap().offset + 1usize; + vm.set_ap(new_ap); assert!(!is_plain( &mut vm, &mut exec_scopes, @@ -875,7 +880,7 @@ mod tests { } ); let pages = match vm.get_output_builtin_mut().unwrap().get_additional_data() { - cairo_vm::vm::runners::cairo_pie::BuiltinAdditionalData::Output(o) => o.pages, + BuiltinAdditionalData::Output(o) => o.pages, _ => unreachable!("Type should be Output"), }; diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index e1e2ec7..bb6afa0 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -502,8 +502,9 @@ mod tests { use rstest::{fixture, rstest}; use crate::hints::codes::EXECUTE_TASK_CALL_TASK; + use crate::ids_data; - use crate::{add_segments, define_segments, ids_data, non_continuous_ids_data, run_hint, vm}; + // use crate::{add_segments, define_segments, ids_data, non_continuous_ids_data, run_hint, vm}; use super::*; @@ -600,8 +601,7 @@ mod tests { // The Fibonacci program has no builtins -> the header size is 4 let header_size = 4; - let code_address: Result = *&program_header_ptr + header_size; - let expected_code_address: Relocatable = code_address.unwrap(); + let expected_code_address = (program_header_ptr + header_size).unwrap(); let program_address: Relocatable = exec_scopes.get(vars::PROGRAM_ADDRESS).unwrap(); assert_eq!(program_address, expected_code_address); diff --git a/src/hints/hint_processor.rs b/src/hints/hint_processor.rs deleted file mode 100644 index 141bb75..0000000 --- a/src/hints/hint_processor.rs +++ /dev/null @@ -1,124 +0,0 @@ -use std::any::Any; -use std::collections::HashMap; - -use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData; -use cairo_vm::hint_processor::builtin_hint_processor::memcpy_hint_utils::exit_scope; -use cairo_vm::hint_processor::hint_processor_definition::HintProcessorLogic; -use cairo_vm::types::exec_scope::ExecutionScopes; -use cairo_vm::vm::errors::hint_errors::HintError; -use cairo_vm::vm::runners::cairo_runner::ResourceTracker; -use cairo_vm::vm::vm_core::VirtualMachine; -use cairo_vm::Felt252; - -use crate::hints::bootloader_hints::{ - assert_is_composite_packed_output, assert_program_address, - compute_and_configure_fact_topologies, enter_packed_output_scope, - guess_pre_image_of_subtasks_output_hash, import_packed_output_schemas, is_plain_packed_output, - load_bootloader_config, prepare_simple_bootloader_input, - prepare_simple_bootloader_output_segment, restore_bootloader_output, save_output_pointer, - save_packed_outputs, set_packed_output_to_subtasks, -}; -use crate::hints::codes::*; -use crate::hints::execute_task_hints::{ - allocate_program_data_segment, append_fact_topologies, call_task, load_program_hint, - validate_hash, write_return_builtins_hint, -}; -use crate::hints::inner_select_builtins::select_builtin; -use crate::hints::select_builtins::select_builtins_enter_scope; -use crate::hints::simple_bootloader_hints::{ - divide_num_by_2, prepare_task_range_checks, set_ap_to_zero, set_current_task, - set_tasks_variable, -}; - -pub struct BootloaderHintProcessor; - -impl BootloaderHintProcessor { - pub fn new() -> Self { - Self {} - } -} - -impl HintProcessorLogic for BootloaderHintProcessor { - fn execute_hint( - &mut self, - vm: &mut VirtualMachine, - exec_scopes: &mut ExecutionScopes, - hint_data: &Box, - _constants: &HashMap, - ) -> Result<(), HintError> { - let hint_data = hint_data - .downcast_ref::() - .ok_or(HintError::WrongHintData)?; - - let ids_data = &hint_data.ids_data; - let ap_tracking = &hint_data.ap_tracking; - - match hint_data.code.as_str() { - BOOTLOADER_RESTORE_BOOTLOADER_OUTPUT => restore_bootloader_output(vm, exec_scopes), - BOOTLOADER_PREPARE_SIMPLE_BOOTLOADER_INPUT => { - prepare_simple_bootloader_input(exec_scopes) - } - BOOTLOADER_LOAD_BOOTLOADER_CONFIG => { - load_bootloader_config(vm, exec_scopes, ids_data, ap_tracking) - } - BOOTLOADER_ENTER_PACKED_OUTPUT_SCOPE => { - enter_packed_output_scope(vm, exec_scopes, ids_data, ap_tracking) - } - BOOTLOADER_SAVE_OUTPUT_POINTER => { - save_output_pointer(vm, exec_scopes, ids_data, ap_tracking) - } - BOOTLOADER_SAVE_PACKED_OUTPUTS => save_packed_outputs(exec_scopes), - BOOTLOADER_GUESS_PRE_IMAGE_OF_SUBTASKS_OUTPUT_HASH => { - guess_pre_image_of_subtasks_output_hash(vm, exec_scopes, ids_data, ap_tracking) - } - BOOTLOADER_PREPARE_SIMPLE_BOOTLOADER_OUTPUT_SEGMENT => { - prepare_simple_bootloader_output_segment(vm, exec_scopes, ids_data, ap_tracking) - } - BOOTLOADER_COMPUTE_FACT_TOPOLOGIES => { - compute_and_configure_fact_topologies(vm, exec_scopes) - } - BOOTLOADER_SET_PACKED_OUTPUT_TO_SUBTASKS => set_packed_output_to_subtasks(exec_scopes), - BOOTLOADER_IMPORT_PACKED_OUTPUT_SCHEMAS => import_packed_output_schemas(), - BOOTLOADER_IS_PLAIN_PACKED_OUTPUT => is_plain_packed_output(vm, exec_scopes), - BOOTLOADER_ASSERT_IS_COMPOSITE_PACKED_OUTPUT => { - assert_is_composite_packed_output(exec_scopes) - } - SIMPLE_BOOTLOADER_PREPARE_TASK_RANGE_CHECKS => { - prepare_task_range_checks(vm, exec_scopes, ids_data, ap_tracking) - } - SIMPLE_BOOTLOADER_SET_TASKS_VARIABLE => set_tasks_variable(exec_scopes), - SIMPLE_BOOTLOADER_DIVIDE_NUM_BY_2 => divide_num_by_2(vm, ids_data, ap_tracking), - SIMPLE_BOOTLOADER_SET_CURRENT_TASK => { - set_current_task(vm, exec_scopes, ids_data, ap_tracking) - } - SIMPLE_BOOTLOADER_ZERO => set_ap_to_zero(vm), - EXECUTE_TASK_ALLOCATE_PROGRAM_DATA_SEGMENT => { - allocate_program_data_segment(vm, exec_scopes, ids_data, ap_tracking) - } - EXECUTE_TASK_LOAD_PROGRAM => load_program_hint(vm, exec_scopes, ids_data, ap_tracking), - EXECUTE_TASK_VALIDATE_HASH => validate_hash(vm, exec_scopes, ids_data, ap_tracking), - EXECUTE_TASK_ASSERT_PROGRAM_ADDRESS => { - assert_program_address(vm, exec_scopes, ids_data, ap_tracking) - } - EXECUTE_TASK_CALL_TASK => call_task(vm, exec_scopes, ids_data, ap_tracking), - EXECUTE_TASK_WRITE_RETURN_BUILTINS => { - write_return_builtins_hint(vm, exec_scopes, ids_data, ap_tracking) - } - EXECUTE_TASK_EXIT_SCOPE => exit_scope(exec_scopes), - EXECUTE_TASK_APPEND_FACT_TOPOLOGIES => { - append_fact_topologies(vm, exec_scopes, ids_data, ap_tracking) - } - SELECT_BUILTINS_ENTER_SCOPE => { - select_builtins_enter_scope(vm, exec_scopes, ids_data, ap_tracking) - } - INNER_SELECT_BUILTINS_SELECT_BUILTIN => { - select_builtin(vm, exec_scopes, ids_data, ap_tracking) - } - unknown_hint_code => Err(HintError::UnknownHint( - unknown_hint_code.to_string().into_boxed_str(), - )), - } - } -} - -impl ResourceTracker for BootloaderHintProcessor {} diff --git a/src/lib.rs b/src/lib.rs index 9cd4457..fbd786f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -5,161 +5,13 @@ pub mod bootloaders; mod hints; pub mod tasks; +#[cfg(test)] +pub mod macros; + /// Inserts the bootloader input in the execution scopes. pub fn insert_bootloader_input( exec_scopes: &mut ExecutionScopes, bootloader_input: BootloaderInput, ) { exec_scopes.insert_value(BOOTLOADER_INPUT, bootloader_input); -} - -#[macro_export] -macro_rules! vm { - () => { - VirtualMachine::new(false) // Default to false if no argument is provided - }; - ($trace_enabled:expr) => { - VirtualMachine::new($trace_enabled) - }; -} - -#[macro_export] -macro_rules! add_segments { - ($vm:expr, $n:expr) => { - for _ in 0..$n { - $vm.add_memory_segment(); - } - }; -} -#[macro_export] -macro_rules! ids_data_old { - ( $( $name: expr ),* ) => { - { - #[allow(clippy::useless_vec)] - let ids_names = vec![$( $name ),*]; - let references = $crate::references!(ids_names.len() as i32); - let mut ids_data = HashMap::::new(); - for (i, name) in ids_names.iter().enumerate() { - ids_data.insert(name.to_string(), references.get(&i).unwrap().clone()); - } - ids_data - } - }; -} -#[macro_export] -macro_rules! ids_data { - ( $( $key:expr ),* ) => {{ - let mut map = HashMap::::new(); - let ids_names = vec![$( $key ),*]; - let ids_len = ids_names.len() as i32; - let mut _value = -ids_len; - $( - map.insert($key.to_string(), cairo_vm::hint_processor::hint_processor_definition::HintReference::new_simple(_value)); - _value += 1; - )* - map - }}; -} -#[macro_export] -macro_rules! references { - ($num: expr) => {{ - let mut references = HashMap::< - usize, - cairo_vm::hint_processor::hint_processor_definition::HintReference, - >::new(); - for i in 0..$num { - references.insert( - i as usize, - cairo_vm::hint_processor::hint_processor_definition::HintReference::new_simple( - (i as i32), - ), - ); - } - references - }}; -} - -#[macro_export] -macro_rules! non_continuous_ids_data { - ( $( ($name: expr, $offset:expr) ),* $(,)? ) => { - { - let mut ids_data = cairo_vm::stdlib::collections::HashMap::::new(); - $( - ids_data.insert(cairo_vm::stdlib::string::String::from($name), HintReference::new_simple($offset)); - )* - ids_data - } - }; -} - -#[macro_export] -macro_rules! insert_value_inner { - ($vm:expr, ($si:expr, $off:expr), ($sival:expr, $offval: expr)) => { - let (k, v) = ( - ($si, $off).into(), - &$crate::mayberelocatable!($sival, $offval), - ); - $vm.insert_value(k, v).unwrap(); - }; - ($vm:expr, ($si:expr, $off:expr), $val:expr) => { - let (k, v) = (($si, $off).into(), &$crate::mayberelocatable!($val)); - $vm.insert_value(k, v).unwrap(); - }; -} - -#[macro_export] -macro_rules! mayberelocatable { - ($val1 : expr, $val2 : expr) => { - cairo_vm::types::relocatable::MaybeRelocatable::from(($val1, $val2)) - }; - ($val1 : expr) => { - cairo_vm::types::relocatable::MaybeRelocatable::from(cairo_vm::Felt252::from($val1 as i128)) - }; -} - -#[macro_export] -macro_rules! define_segments { - ($vm:ident, $count:expr, [$( (($seg1:expr, $off1:expr), $val:tt) ),* $(,)?]) => { - for _ in 0..$count { - $vm.add_memory_segment(); - } - $( - $crate::insert_value_inner!($vm, ($seg1, $off1), $val); - )* - }; -} - -#[macro_export] -macro_rules! run_hint { - ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr, $constants:expr) => {{ - let hint_data = HintProcessorData::new_default($hint_code.to_string(), $ids_data); - let mut hint_processor = $crate::MinimalBootloaderHintProcessor::new(); - hint_processor.execute_hint(&mut $vm, $exec_scopes, &any_box!(hint_data), $constants) - }}; - ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr) => {{ - let hint_data = HintProcessorData::new_default( - cairo_vm::stdlib::string::ToString::to_string($hint_code), - $ids_data, - ); - let mut hint_processor = $crate::MinimalBootloaderHintProcessor::new(); - hint_processor.execute_hint( - &mut $vm, - $exec_scopes, - &any_box!(hint_data), - &cairo_vm::stdlib::collections::HashMap::new(), - ) - }}; - ($vm:expr, $ids_data:expr, $hint_code:expr) => {{ - let hint_data = HintProcessorData::new_default( - $crate::stdlib::string::ToString::to_string($hint_code), - $ids_data, - ); - let mut hint_processor = $crate::MinimalBootloaderHintProcessor::new(); - hint_processor.execute_hint( - &mut $vm, - exec_scopes_ref!(), - &any_box!(hint_data), - &$crate::stdlib::collections::HashMap::new(), - ) - }}; -} +} \ No newline at end of file diff --git a/src/macros.rs b/src/macros.rs new file mode 100644 index 0000000..546df52 --- /dev/null +++ b/src/macros.rs @@ -0,0 +1,134 @@ + +#[macro_export] +macro_rules! vm { + () => { + VirtualMachine::new(false) // Default to false if no argument is provided + }; +} + +#[macro_export] +macro_rules! add_segments { + ($vm:expr, $n:expr) => { + for _ in 0..$n { + $vm.add_memory_segment(); + } + }; +} + +#[macro_export] +macro_rules! ids_data { + ( $( $key:expr ),* ) => {{ + let mut map = HashMap::::new(); + let ids_names = vec![$( $key ),*]; + let ids_len = ids_names.len() as i32; + let mut _value = -ids_len; + $( + map.insert($key.to_string(), cairo_vm::hint_processor::hint_processor_definition::HintReference::new_simple(_value)); + _value += 1; + )* + map + }}; +} +#[macro_export] +macro_rules! references { + ($num: expr) => {{ + let mut references = HashMap::< + usize, + cairo_vm::hint_processor::hint_processor_definition::HintReference, + >::new(); + for i in 0..$num { + references.insert( + i as usize, + cairo_vm::hint_processor::hint_processor_definition::HintReference::new_simple( + (i as i32), + ), + ); + } + references + }}; +} + +#[macro_export] +macro_rules! non_continuous_ids_data { + ( $( ($name: expr, $offset:expr) ),* $(,)? ) => { + { + let mut ids_data = cairo_vm::stdlib::collections::HashMap::::new(); + $( + ids_data.insert(cairo_vm::stdlib::string::String::from($name), HintReference::new_simple($offset)); + )* + ids_data + } + }; +} + +#[macro_export] +macro_rules! insert_value_inner { + ($vm:expr, ($si:expr, $off:expr), ($sival:expr, $offval: expr)) => { + let (k, v) = ( + ($si, $off).into(), + &$crate::mayberelocatable!($sival, $offval), + ); + $vm.insert_value(k, v).unwrap(); + }; + ($vm:expr, ($si:expr, $off:expr), $val:expr) => { + let (k, v) = (($si, $off).into(), &$crate::mayberelocatable!($val)); + $vm.insert_value(k, v).unwrap(); + }; +} + +#[macro_export] +macro_rules! mayberelocatable { + ($val1 : expr, $val2 : expr) => { + cairo_vm::types::relocatable::MaybeRelocatable::from(($val1, $val2)) + }; + ($val1 : expr) => { + cairo_vm::types::relocatable::MaybeRelocatable::from(cairo_vm::Felt252::from($val1 as i128)) + }; +} + +#[macro_export] +macro_rules! define_segments { + ($vm:ident, $count:expr, [$( (($seg1:expr, $off1:expr), $val:tt) ),* $(,)?]) => { + for _ in 0..$count { + $vm.add_memory_segment(); + } + $( + $crate::insert_value_inner!($vm, ($seg1, $off1), $val); + )* + }; +} + +#[macro_export] +macro_rules! run_hint { + ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr, $constants:expr) => {{ + let hint_data = HintProcessorData::new_default($hint_code.to_string(), $ids_data); + let mut hint_processor = $crate::MinimalBootloaderHintProcessor::new(); + hint_processor.execute_hint(&mut $vm, $exec_scopes, &any_box!(hint_data), $constants) + }}; + ($vm:expr, $ids_data:expr, $hint_code:expr, $exec_scopes:expr) => {{ + let hint_data = HintProcessorData::new_default( + cairo_vm::stdlib::string::ToString::to_string($hint_code), + $ids_data, + ); + let mut hint_processor = $crate::MinimalBootloaderHintProcessor::new(); + hint_processor.execute_hint( + &mut $vm, + $exec_scopes, + &any_box!(hint_data), + &cairo_vm::stdlib::collections::HashMap::new(), + ) + }}; + ($vm:expr, $ids_data:expr, $hint_code:expr) => {{ + let hint_data = HintProcessorData::new_default( + $crate::stdlib::string::ToString::to_string($hint_code), + $ids_data, + ); + let mut hint_processor = $crate::MinimalBootloaderHintProcessor::new(); + hint_processor.execute_hint( + &mut $vm, + exec_scopes_ref!(), + &any_box!(hint_data), + &$crate::stdlib::collections::HashMap::new(), + ) + }}; +} From 1a79f21dc5b0f253eb94ebfee494db5256173ae3 Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Thu, 6 Jun 2024 12:59:08 +0300 Subject: [PATCH 25/28] fix: some minor improvements --- src/hints/execute_task_hints.rs | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index bb6afa0..28c7f8c 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -502,9 +502,8 @@ mod tests { use rstest::{fixture, rstest}; use crate::hints::codes::EXECUTE_TASK_CALL_TASK; - use crate::ids_data; - // use crate::{add_segments, define_segments, ids_data, non_continuous_ids_data, run_hint, vm}; + use crate::{add_segments, define_segments, non_continuous_ids_data, ids_data, run_hint, vm}; use super::*; @@ -601,10 +600,10 @@ mod tests { // The Fibonacci program has no builtins -> the header size is 4 let header_size = 4; - let expected_code_address = (program_header_ptr + header_size).unwrap(); + let expected_code_address: Result = program_header_ptr + header_size; let program_address: Relocatable = exec_scopes.get(vars::PROGRAM_ADDRESS).unwrap(); - assert_eq!(program_address, expected_code_address); + assert_eq!(program_address, expected_code_address.unwrap()); // Check that the segment was finalized let expected_program_size = header_size + fibonacci.data_len(); From ee051f1ce4aa937ce87d3bccc1444bce69b18a2c Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Thu, 6 Jun 2024 13:01:13 +0300 Subject: [PATCH 26/28] lint: rustfmt --- src/hints/execute_task_hints.rs | 5 +++-- src/lib.rs | 2 +- src/macros.rs | 1 - 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/hints/execute_task_hints.rs b/src/hints/execute_task_hints.rs index 28c7f8c..c1becaa 100644 --- a/src/hints/execute_task_hints.rs +++ b/src/hints/execute_task_hints.rs @@ -503,7 +503,7 @@ mod tests { use crate::hints::codes::EXECUTE_TASK_CALL_TASK; - use crate::{add_segments, define_segments, non_continuous_ids_data, ids_data, run_hint, vm}; + use crate::{add_segments, define_segments, ids_data, non_continuous_ids_data, run_hint, vm}; use super::*; @@ -600,7 +600,8 @@ mod tests { // The Fibonacci program has no builtins -> the header size is 4 let header_size = 4; - let expected_code_address: Result = program_header_ptr + header_size; + let expected_code_address: Result = + program_header_ptr + header_size; let program_address: Relocatable = exec_scopes.get(vars::PROGRAM_ADDRESS).unwrap(); assert_eq!(program_address, expected_code_address.unwrap()); diff --git a/src/lib.rs b/src/lib.rs index fbd786f..11523f8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -14,4 +14,4 @@ pub fn insert_bootloader_input( bootloader_input: BootloaderInput, ) { exec_scopes.insert_value(BOOTLOADER_INPUT, bootloader_input); -} \ No newline at end of file +} diff --git a/src/macros.rs b/src/macros.rs index 546df52..1651d5f 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -1,4 +1,3 @@ - #[macro_export] macro_rules! vm { () => { From fa29438cbb02c6255de97337fadcfa94e6bcecbc Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Thu, 6 Jun 2024 13:23:54 +0300 Subject: [PATCH 27/28] fix: missing newline --- Cargo.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/Cargo.toml b/Cargo.toml index ae4d641..72862d1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -18,3 +18,4 @@ thiserror-no-std = "2.0.2" [dev-dependencies] assert_matches = "1.5.0" rstest = "0.19.0" + From 96172632f829595bdca498ed418317fc88f5fdac Mon Sep 17 00:00:00 2001 From: Whichqua <170323628+whichqua@users.noreply.github.com> Date: Thu, 6 Jun 2024 15:57:18 +0300 Subject: [PATCH 28/28] fix: remove unused macro --- src/macros.rs | 18 ------------------ 1 file changed, 18 deletions(-) diff --git a/src/macros.rs b/src/macros.rs index 1651d5f..f057a27 100644 --- a/src/macros.rs +++ b/src/macros.rs @@ -28,24 +28,6 @@ macro_rules! ids_data { map }}; } -#[macro_export] -macro_rules! references { - ($num: expr) => {{ - let mut references = HashMap::< - usize, - cairo_vm::hint_processor::hint_processor_definition::HintReference, - >::new(); - for i in 0..$num { - references.insert( - i as usize, - cairo_vm::hint_processor::hint_processor_definition::HintReference::new_simple( - (i as i32), - ), - ); - } - references - }}; -} #[macro_export] macro_rules! non_continuous_ids_data {