From ab4fb11434e2cc5e236bc0c6bfea55bbcc28ac5f Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Tue, 8 Oct 2024 10:21:10 +0300 Subject: [PATCH 01/57] refactor(blockifier): resource cost ratio type changed to u64 ratio from u128 ratio (#1174) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1174) --- .../blockifier/src/execution/entry_point.rs | 17 +++++++++++------ crates/blockifier/src/fee/fee_test.rs | 8 ++++---- crates/blockifier/src/fee/fee_utils.rs | 6 +++--- crates/blockifier/src/fee/gas_usage_test.rs | 9 ++++++--- crates/blockifier/src/fee/receipt_test.rs | 17 +++++++++-------- crates/blockifier/src/fee/resources.rs | 17 +++++++++++------ crates/blockifier/src/test_utils.rs | 4 ---- crates/blockifier/src/transaction/errors.rs | 2 ++ crates/blockifier/src/utils.rs | 12 ++++++++++++ crates/blockifier/src/versioned_constants.rs | 19 +++++++++++++++---- 10 files changed, 73 insertions(+), 38 deletions(-) diff --git a/crates/blockifier/src/execution/entry_point.rs b/crates/blockifier/src/execution/entry_point.rs index bb0cb922788..c2385aa7eba 100644 --- a/crates/blockifier/src/execution/entry_point.rs +++ b/crates/blockifier/src/execution/entry_point.rs @@ -28,7 +28,7 @@ use crate::execution::execution_utils::execute_entry_point_call_wrapper; use crate::state::state_api::{State, StateResult}; use crate::transaction::objects::{HasRelatedFeeType, TransactionInfo}; use crate::transaction::transaction_types::TransactionType; -use crate::utils::usize_from_u128; +use crate::utils::usize_from_u64; use crate::versioned_constants::{GasCosts, VersionedConstants}; #[cfg(test)] @@ -288,14 +288,19 @@ impl EntryPointExecutionContext { // Use saturating upper bound to avoid overflow. This is safe because the upper bound is // bounded above by the block's limit, which is a usize. - let upper_bound_u128 = if gas_per_step.is_zero() { - u128::MAX + let upper_bound_u64 = if gas_per_step.is_zero() { + u64::MAX } else { - (gas_per_step.inv() * tx_gas_upper_bound.0).to_integer() + // TODO: This panic will disappear once GasAmount is a u64. + (gas_per_step.inv() + * u64::try_from(tx_gas_upper_bound.0).unwrap_or_else(|_| { + panic!("Gas amounts cannot be more than 64 bits; got {tx_gas_upper_bound:?}.") + })) + .to_integer() }; - let tx_upper_bound = usize_from_u128(upper_bound_u128).unwrap_or_else(|_| { + let tx_upper_bound = usize_from_u64(upper_bound_u64).unwrap_or_else(|_| { log::warn!( - "Failed to convert u128 to usize: {upper_bound_u128}. Upper bound from tx is \ + "Failed to convert u64 to usize: {upper_bound_u64}. Upper bound from tx is \ {tx_gas_upper_bound}, gas per step is {gas_per_step}." ); usize::MAX diff --git a/crates/blockifier/src/fee/fee_test.rs b/crates/blockifier/src/fee/fee_test.rs index b15e9d871b6..bd7a310e2b1 100644 --- a/crates/blockifier/src/fee/fee_test.rs +++ b/crates/blockifier/src/fee/fee_test.rs @@ -30,7 +30,7 @@ use crate::test_utils::{ }; use crate::transaction::objects::FeeType; use crate::transaction::test_utils::{account_invoke_tx, all_resource_bounds, l1_resource_bounds}; -use crate::utils::u128_from_usize; +use crate::utils::{u128_from_usize, u64_from_usize}; use crate::versioned_constants::VersionedConstants; fn get_vm_resource_usage() -> ExecutionResources { @@ -59,7 +59,7 @@ fn test_simple_get_vm_resource_usage( // Positive flow. // Verify calculation - in our case, n_steps is the heaviest resource. let vm_usage_in_l1_gas = (versioned_constants.vm_resource_fee_cost().n_steps - * (u128_from_usize(vm_resource_usage.n_steps + n_reverted_steps))) + * (u64_from_usize(vm_resource_usage.n_steps + n_reverted_steps))) .ceil() .to_integer() .into(); @@ -114,7 +114,7 @@ fn test_float_get_vm_resource_usage( // Verify calculation - in our case, n_steps is the heaviest resource. let n_reverted_steps = 300; let vm_usage_in_l1_gas = (versioned_constants.vm_resource_fee_cost().n_steps - * u128_from_usize(vm_resource_usage.n_steps + n_reverted_steps)) + * u64_from_usize(vm_resource_usage.n_steps + n_reverted_steps)) .ceil() .to_integer() .into(); @@ -137,7 +137,7 @@ fn test_float_get_vm_resource_usage( vm_resource_usage.n_steps = 200; let vm_usage_in_l1_gas = ((*versioned_constants.vm_resource_fee_cost().builtins.get(&BuiltinName::ecdsa).unwrap()) - * u128_from_usize( + * u64_from_usize( *vm_resource_usage.builtin_instance_counter.get(&BuiltinName::ecdsa).unwrap(), )) .ceil() diff --git a/crates/blockifier/src/fee/fee_utils.rs b/crates/blockifier/src/fee/fee_utils.rs index 9a87eba0a89..3a622135285 100644 --- a/crates/blockifier/src/fee/fee_utils.rs +++ b/crates/blockifier/src/fee/fee_utils.rs @@ -17,7 +17,7 @@ use crate::fee::resources::{GasVector, TransactionFeeResult}; use crate::state::state_api::StateReader; use crate::transaction::errors::TransactionFeeError; use crate::transaction::objects::{ExecutionResourcesTraits, FeeType, TransactionInfo}; -use crate::utils::u128_from_usize; +use crate::utils::u64_from_usize; use crate::versioned_constants::VersionedConstants; #[cfg(test)] @@ -62,8 +62,8 @@ pub fn get_vm_resources_cost( vm_resource_fee_costs.n_steps, vm_resource_usage.total_n_steps() + n_reverted_steps, )]) - .map(|(cost, usage)| (cost * u128_from_usize(usage)).ceil().to_integer()) - .fold(0, u128::max).into(); + .map(|(cost, usage)| (cost * u64_from_usize(usage)).ceil().to_integer()) + .fold(0, u64::max).into(); match computation_mode { GasVectorComputationMode::NoL2Gas => GasVector::from_l1_gas(vm_l1_gas_usage), diff --git a/crates/blockifier/src/fee/gas_usage_test.rs b/crates/blockifier/src/fee/gas_usage_test.rs index b343eba056f..12e65ae4178 100644 --- a/crates/blockifier/src/fee/gas_usage_test.rs +++ b/crates/blockifier/src/fee/gas_usage_test.rs @@ -15,7 +15,7 @@ use crate::state::cached_state::StateChangesCount; use crate::test_utils::{DEFAULT_ETH_L1_DATA_GAS_PRICE, DEFAULT_ETH_L1_GAS_PRICE}; use crate::transaction::objects::FeeType; use crate::transaction::test_utils::account_invoke_tx; -use crate::utils::u128_from_usize; +use crate::utils::{u128_from_usize, u64_from_usize}; use crate::versioned_constants::{ResourceCost, VersionedConstants}; #[fixture] fn versioned_constants() -> &'static VersionedConstants { @@ -88,7 +88,7 @@ fn test_get_event_gas_cost( .collect(); let execution_summary = CallInfo::summarize_many(call_infos.iter()); // 8 keys and 11 data words overall. - let expected_gas = (data_word_cost * (event_key_factor * 8_u128 + 11_u128)).to_integer().into(); + let expected_gas = (data_word_cost * (event_key_factor * 8_u64 + 11_u64)).to_integer().into(); let expected_gas_vector = match gas_vector_computation_mode { GasVectorComputationMode::NoL2Gas => GasVector::from_l1_gas(expected_gas), GasVectorComputationMode::All => GasVector::from_l2_gas(expected_gas), @@ -193,7 +193,10 @@ fn test_onchain_data_discount() { let cost_without_discount = (state_changes_count.n_storage_updates * 2) * (512 + 100); let actual_cost = get_da_gas_cost(&state_changes_count, use_kzg_da).l1_gas; - let cost_ratio = ResourceCost::new(actual_cost.0, u128_from_usize(cost_without_discount)); + let cost_ratio = ResourceCost::new( + u64::try_from(actual_cost.0).unwrap(), + u64_from_usize(cost_without_discount), + ); assert!(cost_ratio <= ResourceCost::new(9, 10)); assert!(cost_ratio >= ResourceCost::new(88, 100)); } diff --git a/crates/blockifier/src/fee/receipt_test.rs b/crates/blockifier/src/fee/receipt_test.rs index 0cde3cbd92d..3d37685f015 100644 --- a/crates/blockifier/src/fee/receipt_test.rs +++ b/crates/blockifier/src/fee/receipt_test.rs @@ -30,7 +30,7 @@ use crate::transaction::test_utils::{ create_resource_bounds, }; use crate::transaction::transactions::ExecutableTransaction; -use crate::utils::{u128_from_usize, usize_from_u128}; +use crate::utils::{u128_from_usize, u64_from_usize, usize_from_u128}; use crate::versioned_constants::VersionedConstants; #[fixture] @@ -82,7 +82,7 @@ fn test_calculate_tx_gas_usage_basic<'a>( .get_archival_data_gas_costs(&gas_vector_computation_mode) .gas_per_code_byte; let code_gas_cost = (gas_per_code_byte - * u128_from_usize( + * u64_from_usize( (class_info.bytecode_length() + class_info.sierra_program_length()) * eth_gas_constants::WORD_WIDTH + class_info.abi_length(), @@ -124,9 +124,9 @@ fn test_calculate_tx_gas_usage_basic<'a>( let gas_per_data_felt = versioned_constants .get_archival_data_gas_costs(&gas_vector_computation_mode) .gas_per_data_felt; - let calldata_and_signature_gas_cost = (gas_per_data_felt - * u128_from_usize(calldata_length + signature_length)) - .to_integer() + let calldata_and_signature_gas_cost = u128::from( + (gas_per_data_felt * u64_from_usize(calldata_length + signature_length)).to_integer(), + ) .into(); let manual_starknet_gas_usage_vector = match gas_vector_computation_mode { GasVectorComputationMode::NoL2Gas => { @@ -163,9 +163,10 @@ fn test_calculate_tx_gas_usage_basic<'a>( // Manual calculation. let message_segment_length = get_message_segment_length(&[], Some(l1_handler_payload_size)); - let calldata_and_signature_gas_cost = (gas_per_data_felt - * u128_from_usize(l1_handler_payload_size + signature_length)) - .to_integer() + let calldata_and_signature_gas_cost = u128::from( + (gas_per_data_felt * u64_from_usize(l1_handler_payload_size + signature_length)) + .to_integer(), + ) .into(); let calldata_and_signature_gas_cost_vector = match gas_vector_computation_mode { GasVectorComputationMode::NoL2Gas => { diff --git a/crates/blockifier/src/fee/resources.rs b/crates/blockifier/src/fee/resources.rs index 07687526364..0ded29654bb 100644 --- a/crates/blockifier/src/fee/resources.rs +++ b/crates/blockifier/src/fee/resources.rs @@ -19,8 +19,12 @@ use crate::fee::gas_usage::{ use crate::state::cached_state::{StateChanges, StateChangesCount}; use crate::transaction::errors::TransactionFeeError; use crate::transaction::objects::HasRelatedFeeType; -use crate::utils::u128_from_usize; -use crate::versioned_constants::{ArchivalDataGasCosts, VersionedConstants}; +use crate::utils::{u128_from_usize, u64_from_usize}; +use crate::versioned_constants::{ + resource_cost_to_u128_ratio, + ArchivalDataGasCosts, + VersionedConstants, +}; pub type TransactionFeeResult = Result; @@ -203,20 +207,21 @@ impl ArchivalDataResources { archival_gas_costs: &ArchivalDataGasCosts, ) -> GasAmount { // TODO(Avi, 20/2/2024): Calculate the number of bytes instead of the number of felts. - let total_data_size = u128_from_usize(self.calldata_length + self.signature_length); + let total_data_size = u64_from_usize(self.calldata_length + self.signature_length); (archival_gas_costs.gas_per_data_felt * total_data_size).to_integer().into() } /// Returns the cost of declared class codes in L1/L2 gas units, depending on the mode. fn get_code_gas_cost(&self, archival_gas_costs: &ArchivalDataGasCosts) -> GasAmount { - (archival_gas_costs.gas_per_code_byte * u128_from_usize(self.code_size)).to_integer().into() + (archival_gas_costs.gas_per_code_byte * u64_from_usize(self.code_size)).to_integer().into() } /// Returns the cost of the transaction's emmited events in L1/L2 gas units, depending on the /// mode. fn get_events_gas_cost(&self, archival_gas_costs: &ArchivalDataGasCosts) -> GasAmount { - (archival_gas_costs.gas_per_data_felt - * (archival_gas_costs.event_key_factor * self.event_summary.total_event_keys + (resource_cost_to_u128_ratio(archival_gas_costs.gas_per_data_felt) + * (resource_cost_to_u128_ratio(archival_gas_costs.event_key_factor) + * self.event_summary.total_event_keys + self.event_summary.total_event_data_size)) .to_integer() .into() diff --git a/crates/blockifier/src/test_utils.rs b/crates/blockifier/src/test_utils.rs index c96562f8484..af8e837997b 100644 --- a/crates/blockifier/src/test_utils.rs +++ b/crates/blockifier/src/test_utils.rs @@ -382,10 +382,6 @@ pub fn create_trivial_calldata(test_contract_address: ContractAddress) -> Callda ) } -pub fn u64_from_usize(val: usize) -> u64 { - val.try_into().unwrap() -} - pub fn update_json_value(base: &mut serde_json::Value, update: serde_json::Value) { match (base, update) { (serde_json::Value::Object(base_map), serde_json::Value::Object(update_map)) => { diff --git a/crates/blockifier/src/transaction/errors.rs b/crates/blockifier/src/transaction/errors.rs index 52e7aa0a54e..804ada40fd7 100644 --- a/crates/blockifier/src/transaction/errors.rs +++ b/crates/blockifier/src/transaction/errors.rs @@ -166,4 +166,6 @@ pub enum ParseError { pub enum NumericConversionError { #[error("Conversion of {0} to u128 unsuccessful.")] U128ToUsizeError(u128), + #[error("Conversion of {0} to u64 unsuccessful.")] + U64ToUsizeError(u64), } diff --git a/crates/blockifier/src/utils.rs b/crates/blockifier/src/utils.rs index 5a75bc5e2d9..9e70cf5f905 100644 --- a/crates/blockifier/src/utils.rs +++ b/crates/blockifier/src/utils.rs @@ -54,8 +54,20 @@ pub fn usize_from_u128(val: u128) -> Result { val.try_into().map_err(|_| NumericConversionError::U128ToUsizeError(val)) } +/// Conversion from u64 to usize. This conversion should only be used if the value came from a +/// usize. +pub fn usize_from_u64(val: u64) -> Result { + val.try_into().map_err(|_| NumericConversionError::U64ToUsizeError(val)) +} + /// Conversion from usize to u128. May fail on architectures with over 128 bits /// of address space. pub fn u128_from_usize(val: usize) -> u128 { val.try_into().expect("Conversion from usize to u128 should not fail.") } + +/// Conversion from usize to u64. May fail on architectures with over 64 bits +/// of address space. +pub fn u64_from_usize(val: usize) -> u64 { + val.try_into().expect("Conversion from usize to u64 should not fail.") +} diff --git a/crates/blockifier/src/versioned_constants.rs b/crates/blockifier/src/versioned_constants.rs index c6da2022d7e..9b846d190b3 100644 --- a/crates/blockifier/src/versioned_constants.rs +++ b/crates/blockifier/src/versioned_constants.rs @@ -135,7 +135,12 @@ define_versioned_constants! { V0_13_3 } -pub type ResourceCost = Ratio; +pub type ResourceCost = Ratio; + +pub fn resource_cost_to_u128_ratio(cost: ResourceCost) -> Ratio { + Ratio::new((*cost.numer()).into(), (*cost.denom()).into()) +} + #[derive(Clone, Debug, Deserialize, Eq, PartialEq, PartialOrd)] pub struct CompilerVersion(pub Version); impl Default for CompilerVersion { @@ -222,18 +227,24 @@ impl VersionedConstants { /// Converts from L1 gas price to L2 gas price with **upward rounding**. pub fn convert_l1_to_l2_gas_price_round_up(&self, l1_gas_price: GasPrice) -> GasPrice { - (*(self.l1_to_l2_gas_price_ratio() * l1_gas_price.0).ceil().numer()).into() + (*(resource_cost_to_u128_ratio(self.l1_to_l2_gas_price_ratio()) * l1_gas_price.0) + .ceil() + .numer()) + .into() } /// Converts from L1 gas amount to L2 gas amount with **upward rounding**. pub fn convert_l1_to_l2_gas_amount_round_up(&self, l1_gas_amount: GasAmount) -> GasAmount { // The amount ratio is the inverse of the price ratio. - (*(self.l1_to_l2_gas_price_ratio().inv() * l1_gas_amount.0).ceil().numer()).into() + (*(resource_cost_to_u128_ratio(self.l1_to_l2_gas_price_ratio().inv()) * l1_gas_amount.0) + .ceil() + .numer()) + .into() } /// Returns the following ratio: L2_gas_price/L1_gas_price. fn l1_to_l2_gas_price_ratio(&self) -> ResourceCost { - Ratio::new(1, u128::from(self.os_constants.gas_costs.step_gas_cost)) + Ratio::new(1, self.os_constants.gas_costs.step_gas_cost) * self.vm_resource_fee_cost().n_steps } From 12528f1afc1f34b88af98d1b4acd2a2804cb7ddc Mon Sep 17 00:00:00 2001 From: eitanm-starkware Date: Mon, 7 Oct 2024 17:05:33 +0300 Subject: [PATCH 02/57] feat(ci): add mempool p2p to commitlint --- commitlint.config.js | 2 ++ 1 file changed, 2 insertions(+) diff --git a/commitlint.config.js b/commitlint.config.js index 7d36875ed47..a57cebcf7ec 100644 --- a/commitlint.config.js +++ b/commitlint.config.js @@ -41,6 +41,8 @@ const Configuration = { 'mempool', 'mempool_infra', 'mempool_node', + 'mempool_p2p', + 'mempool_p2p_types', 'mempool_test_utils', 'mempool_types', 'monitoring', From 7ed164b7b6893516c6035f9aa8618705c0c5e650 Mon Sep 17 00:00:00 2001 From: Elin Date: Tue, 8 Oct 2024 11:37:04 +0300 Subject: [PATCH 03/57] fix(mempool): bug fix in mempool input validation (#1231) --- crates/mempool/src/mempool.rs | 2 +- crates/mempool/src/mempool_test.rs | 25 +++++++++++++++---------- 2 files changed, 16 insertions(+), 11 deletions(-) diff --git a/crates/mempool/src/mempool.rs b/crates/mempool/src/mempool.rs index 369487e961b..baa254255d7 100644 --- a/crates/mempool/src/mempool.rs +++ b/crates/mempool/src/mempool.rs @@ -154,7 +154,7 @@ impl Mempool { if self .tx_queue .get_nonce(sender_address) - .is_some_and(|queued_nonce| queued_nonce > tx_nonce) + .is_some_and(|queued_nonce| queued_nonce >= tx_nonce) { return Err(duplicate_nonce_error); } diff --git a/crates/mempool/src/mempool_test.rs b/crates/mempool/src/mempool_test.rs index a9f9e335e38..8bdc4ef1870 100644 --- a/crates/mempool/src/mempool_test.rs +++ b/crates/mempool/src/mempool_test.rs @@ -391,10 +391,10 @@ fn test_add_tx_multi_nonce_success(mut mempool: Mempool) { } #[rstest] -fn test_add_tx_with_duplicate_tx(mut mempool: Mempool) { +fn test_add_tx_failure_on_duplicate_tx_hash(mut mempool: Mempool) { // Setup. - let input = add_tx_input!(tip: 50, tx_hash: 1); - let duplicate_input = input.clone(); + let input = add_tx_input!(tx_hash: 1, tx_nonce: 1, account_nonce: 0); + let duplicate_input = input.clone(); // Same hash is possible if signature is different. // Test. add_tx(&mut mempool, &input); @@ -423,13 +423,18 @@ fn test_add_tx_lower_than_queued_nonce() { .build_into_mempool(); // Test and assert: original transaction remains. - let lower_nonce_input = - add_tx_input!(tx_hash: 2, sender_address: "0x0", tx_nonce: 0, account_nonce: 0); - add_tx_expect_error( - &mut mempool, - &lower_nonce_input, - MempoolError::DuplicateNonce { address: contract_address!("0x0"), nonce: nonce!(0) }, - ); + for tx_nonce in [0, 1] { + let invalid_input = + add_tx_input!(tx_hash: 2, sender_address: "0x0", tx_nonce: tx_nonce, account_nonce: 0); + add_tx_expect_error( + &mut mempool, + &invalid_input, + MempoolError::DuplicateNonce { + address: contract_address!("0x0"), + nonce: nonce!(tx_nonce), + }, + ); + } let expected_mempool_content = MempoolContentBuilder::new() .with_pool(pool_txs) From b44a038b4b7c9fd1ece663c9f3f5714c5eafd5b2 Mon Sep 17 00:00:00 2001 From: eitanm-starkware Date: Mon, 7 Oct 2024 17:06:52 +0300 Subject: [PATCH 04/57] feat(mempool_p2p): create init for receiver and sender --- Cargo.lock | 1 + crates/mempool_p2p/Cargo.toml | 1 + crates/mempool_p2p/src/receiver/mod.rs | 25 ++++++++++++++++++++++++- crates/mempool_p2p/src/sender/mod.rs | 13 ++++++++++++- 4 files changed, 38 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a1eea94bce7..433ec090405 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10424,6 +10424,7 @@ version = "0.0.0" dependencies = [ "async-trait", "papyrus_network", + "papyrus_protobuf", "starknet_mempool_infra", "starknet_mempool_p2p_types", ] diff --git a/crates/mempool_p2p/Cargo.toml b/crates/mempool_p2p/Cargo.toml index 1a3413df1d0..5fe3540ec7c 100644 --- a/crates/mempool_p2p/Cargo.toml +++ b/crates/mempool_p2p/Cargo.toml @@ -11,5 +11,6 @@ workspace = true [dependencies] async-trait.workspace = true papyrus_network.workspace = true +papyrus_protobuf.workspace = true starknet_mempool_infra.workspace = true starknet_mempool_p2p_types.workspace = true diff --git a/crates/mempool_p2p/src/receiver/mod.rs b/crates/mempool_p2p/src/receiver/mod.rs index 7b646e2cf20..9d5fdd92767 100644 --- a/crates/mempool_p2p/src/receiver/mod.rs +++ b/crates/mempool_p2p/src/receiver/mod.rs @@ -1,5 +1,28 @@ +use papyrus_network::network_manager::{ + BroadcastTopicClient, + BroadcastTopicServer, + NetworkManager, +}; +use papyrus_protobuf::mempool::RpcTransactionWrapper; use starknet_mempool_infra::component_definitions::ComponentStarter; -pub struct MempoolP2pReceiver; +pub struct MempoolP2pReceiver { + #[allow(dead_code)] + network_manager: Option, + #[allow(dead_code)] + broadcasted_messages_server: BroadcastTopicServer, + #[allow(dead_code)] + broadcast_messages_client: BroadcastTopicClient, +} + +impl MempoolP2pReceiver { + pub fn new( + network_manager: Option, + broadcasted_messages_server: BroadcastTopicServer, + broadcast_messages_client: BroadcastTopicClient, + ) -> Self { + Self { network_manager, broadcasted_messages_server, broadcast_messages_client } + } +} impl ComponentStarter for MempoolP2pReceiver {} diff --git a/crates/mempool_p2p/src/sender/mod.rs b/crates/mempool_p2p/src/sender/mod.rs index 4cb1921ae6e..5122b0f6954 100644 --- a/crates/mempool_p2p/src/sender/mod.rs +++ b/crates/mempool_p2p/src/sender/mod.rs @@ -1,11 +1,22 @@ use async_trait::async_trait; +use papyrus_network::network_manager::BroadcastTopicClient; +use papyrus_protobuf::mempool::RpcTransactionWrapper; use starknet_mempool_infra::component_definitions::ComponentRequestHandler; use starknet_mempool_p2p_types::communication::{ MempoolP2pSenderRequest, MempoolP2pSenderResponse, }; -pub struct MempoolP2pSender; +pub struct MempoolP2pSender { + #[allow(dead_code)] + broadcast_topic_client: BroadcastTopicClient, +} + +impl MempoolP2pSender { + pub fn new(broadcast_topic_client: BroadcastTopicClient) -> Self { + Self { broadcast_topic_client } + } +} #[async_trait] impl ComponentRequestHandler From abb5f83a8e043ced447bc8dc68eea72a686596b9 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Tue, 8 Oct 2024 12:12:43 +0300 Subject: [PATCH 05/57] feat(ci): no committer benchmarks in post-merge (#1134) Signed-off-by: Dori Medini --- .github/workflows/committer_ci.yml | 51 ---------------- .github/workflows/committer_cli_push.yml | 76 ++++++++++++++++++++++++ 2 files changed, 76 insertions(+), 51 deletions(-) create mode 100644 .github/workflows/committer_cli_push.yml diff --git a/.github/workflows/committer_ci.yml b/.github/workflows/committer_ci.yml index c4cf79d2fe4..5a596c2dbf8 100644 --- a/.github/workflows/committer_ci.yml +++ b/.github/workflows/committer_ci.yml @@ -1,22 +1,6 @@ name: Committer-CI on: - push: - branches: - - main - - main-v[0-9].** - tags: - - v[0-9].** - paths: - - '.github/workflows/committer_ci.yml' - - 'Cargo.toml' - - 'Cargo.lock' - - 'crates/committer_cli/**' - - 'crates/starknet_api/**' - - 'crates/starknet_committer/**' - - 'crates/starknet_patricia/**' - - 'scripts/dependencies.sh' - pull_request: types: - opened @@ -121,38 +105,3 @@ jobs: body: fs.readFileSync('bench_new.txt', 'utf8'), path: 'Commits' }) - - gcs-push: - runs-on: starkware-ubuntu-20-04-medium - steps: - - uses: actions/checkout@v4 - - uses: ./.github/actions/bootstrap - - # Commit hash on pull request event would be the head commit of the branch. - - name: Get commit hash prefix for PR update - if: ${{ github.event_name == 'pull_request' }} - env: - COMMIT_SHA: ${{ github.event.pull_request.head.sha }} - run: echo "SHORT_HASH=${COMMIT_SHA:0:7}" >> $GITHUB_ENV - - # On push event (to main, for example) we should take the commit post-push. - - name: Get commit hash prefix for merge - if: ${{ github.event_name != 'pull_request' }} - env: - COMMIT_SHA: ${{ github.event.after }} - run: echo "SHORT_HASH=${COMMIT_SHA:0:7}" >> $GITHUB_ENV - - - name: Build CLI binary - run: ./build_native_in_docker.sh cargo build -p committer_cli -r --bin committer_cli --target-dir CLI_TARGET - - - id: auth - uses: "google-github-actions/auth@v2" - with: - credentials_json: ${{ secrets.COMMITER_PRODUCTS_EXT_WRITER_JSON }} - - - name: Upload binary to GCP - id: upload_file - uses: "google-github-actions/upload-cloud-storage@v2" - with: - path: "CLI_TARGET/release/committer_cli" - destination: "committer-products-external/${{ env.SHORT_HASH }}/release/" diff --git a/.github/workflows/committer_cli_push.yml b/.github/workflows/committer_cli_push.yml new file mode 100644 index 00000000000..87ab28fbc93 --- /dev/null +++ b/.github/workflows/committer_cli_push.yml @@ -0,0 +1,76 @@ +name: Committer-CLI-push + +on: + push: + branches: + - main + - main-v[0-9].** + tags: + - v[0-9].** + paths: + - '.github/workflows/committer_cli_push.yml' + - 'Cargo.toml' + - 'Cargo.lock' + - 'crates/committer_cli/**' + - 'crates/starknet_api/**' + - 'crates/starknet_committer/**' + - 'crates/starknet_patricia/**' + - 'scripts/dependencies.sh' + + pull_request: + types: + - opened + - reopened + - synchronize + - auto_merge_enabled + - edited + paths: + - '.github/workflows/committer_cli_push.yml' + - 'Cargo.toml' + - 'Cargo.lock' + - 'crates/committer_cli/**' + - 'crates/starknet_api/**' + - 'crates/starknet_committer/**' + - 'crates/starknet_patricia/**' + - 'scripts/dependencies.sh' + +# On PR events, cancel existing CI runs on this same PR for this workflow. +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: ${{ github.event_name == 'pull_request' }}-${{ github.job }} + +jobs: + gcs-push: + runs-on: starkware-ubuntu-20-04-medium + steps: + - uses: actions/checkout@v4 + - uses: ./.github/actions/bootstrap + + # Commit hash on pull request event would be the head commit of the branch. + - name: Get commit hash prefix for PR update + if: ${{ github.event_name == 'pull_request' }} + env: + COMMIT_SHA: ${{ github.event.pull_request.head.sha }} + run: echo "SHORT_HASH=${COMMIT_SHA:0:7}" >> $GITHUB_ENV + + # On push event (to main, for example) we should take the commit post-push. + - name: Get commit hash prefix for merge + if: ${{ github.event_name != 'pull_request' }} + env: + COMMIT_SHA: ${{ github.event.after }} + run: echo "SHORT_HASH=${COMMIT_SHA:0:7}" >> $GITHUB_ENV + + - name: Build CLI binary + run: ./build_native_in_docker.sh cargo build -p committer_cli -r --bin committer_cli --target-dir CLI_TARGET + + - id: auth + uses: "google-github-actions/auth@v2" + with: + credentials_json: ${{ secrets.COMMITER_PRODUCTS_EXT_WRITER_JSON }} + + - name: Upload binary to GCP + id: upload_file + uses: "google-github-actions/upload-cloud-storage@v2" + with: + path: "CLI_TARGET/release/committer_cli" + destination: "committer-products-external/${{ env.SHORT_HASH }}/release/" From 733658aa2fed3574c9511f6c4dab094536c139d7 Mon Sep 17 00:00:00 2001 From: giladchase Date: Tue, 8 Oct 2024 13:41:01 +0300 Subject: [PATCH 06/57] chore(tests-integration): gw-mp tests scaffolding (#1251) Co-Authored-By: Gilad Chase --- .../tests/gateway_mempool_tests.rs | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 crates/tests-integration/tests/gateway_mempool_tests.rs diff --git a/crates/tests-integration/tests/gateway_mempool_tests.rs b/crates/tests-integration/tests/gateway_mempool_tests.rs new file mode 100644 index 00000000000..51b9023f328 --- /dev/null +++ b/crates/tests-integration/tests/gateway_mempool_tests.rs @@ -0,0 +1,41 @@ +#[tokio::test] +#[ignore = "Not yet implemented: Simulate mempool non-responsiveness without crash (simulate \ + latency issue)"] +async fn test_mempool_non_responsive() {} + +#[tokio::test] +#[ignore = "Not yet implemented: On crash, mempool resets and starts empty"] +async fn test_mempool_crash() {} + +#[tokio::test] +#[ignore = "Not yet implemented: Simulate gateway state non-responsiveness (latency issue)"] +async fn test_gateway_state_non_responsive() {} + +#[tokio::test] +#[ignore = "Not yet implemented: Add high-priority transaction to a full mempool"] +async fn test_add_tx_high_priority_full_mempool() {} + +#[tokio::test] +#[ignore = "Not yet implemented: Add low-priority transaction to a full mempool (should not enter)"] +async fn test_add_tx_low_priority_full_mempool() {} + +#[tokio::test] +#[ignore = "Not yet implemented: Simulate a single account sending many transactions (e.g., an \ + exchange)"] +async fn test_single_account_stress() {} + +#[tokio::test] +#[ignore = "Not yet implemented"] +async fn test_duplicate_tx_error_handling() {} + +#[tokio::test] +#[ignore = "Not yet implemented"] +async fn test_duplicate_nonce_error_handling() {} + +#[tokio::test] +#[ignore = "Not yet implemented: go over edge cases that occur when commit_block arrived at the + mempool before it arrived at the gateway, and vice versa. For example, account nonces + in the GW during add_tx will be different from what the mempool knows about. + NOTE: this is for after the first POC, in the first POC the mempool tracks account + nonces internally, indefinitely (which is of course not scalable and is only for POC)"] +async fn test_commit_block_races() {} From 3aa38b18705fa94ecaf37a37f87b014260d7d8da Mon Sep 17 00:00:00 2001 From: yoavGrs <97383386+yoavGrs@users.noreply.github.com> Date: Tue, 8 Oct 2024 13:43:06 +0300 Subject: [PATCH 07/57] feat(starknet_api): backward compatibility for empty signatures (#1201) --- crates/committer_cli/src/block_hash.rs | 3 ++- crates/committer_cli/src/main.rs | 1 + .../src/block_hash/block_hash_calculator.rs | 15 +++++++++++++-- .../src/block_hash/block_hash_calculator_test.rs | 8 ++++++-- 4 files changed, 22 insertions(+), 5 deletions(-) diff --git a/crates/committer_cli/src/block_hash.rs b/crates/committer_cli/src/block_hash.rs index d78f5b19daf..ba4418ecbf1 100644 --- a/crates/committer_cli/src/block_hash.rs +++ b/crates/committer_cli/src/block_hash.rs @@ -1,5 +1,5 @@ use serde::Deserialize; -use starknet_api::block::BlockHeaderWithoutHash; +use starknet_api::block::{BlockHeaderWithoutHash, StarknetVersion}; use starknet_api::block_hash::block_hash_calculator::{ BlockHeaderCommitments, TransactionHashingData, @@ -12,6 +12,7 @@ pub struct BlockCommitmentsInput { pub transactions_data: Vec, pub state_diff: ThinStateDiff, pub l1_da_mode: L1DataAvailabilityMode, + pub starknet_version: StarknetVersion, } #[derive(Clone, Debug, Deserialize, Eq, PartialEq)] diff --git a/crates/committer_cli/src/main.rs b/crates/committer_cli/src/main.rs index 9d57a647534..43040f61946 100644 --- a/crates/committer_cli/src/main.rs +++ b/crates/committer_cli/src/main.rs @@ -103,6 +103,7 @@ async fn main() { &commitments_input.transactions_data, &commitments_input.state_diff, commitments_input.l1_da_mode, + &commitments_input.starknet_version, ); write_to_file(&output_path, &commitments); info!("Successfully computed block hash commitment: \n{:?}", commitments); diff --git a/crates/starknet_api/src/block_hash/block_hash_calculator.rs b/crates/starknet_api/src/block_hash/block_hash_calculator.rs index 27dab67dbdf..a74555f1304 100644 --- a/crates/starknet_api/src/block_hash/block_hash_calculator.rs +++ b/crates/starknet_api/src/block_hash/block_hash_calculator.rs @@ -127,9 +127,20 @@ pub fn calculate_block_commitments( transactions_data: &[TransactionHashingData], state_diff: &ThinStateDiff, l1_da_mode: L1DataAvailabilityMode, + starknet_version: &StarknetVersion, ) -> BlockHeaderCommitments { - let transaction_leaf_elements: Vec = - transactions_data.iter().map(TransactionLeafElement::from).collect(); + let transaction_leaf_elements: Vec = transactions_data + .iter() + .map(|tx_leaf| { + let mut tx_leaf_element = TransactionLeafElement::from(tx_leaf); + if starknet_version < &BlockHashVersion::VO_13_3.into() + && tx_leaf.transaction_signature.0.is_empty() + { + tx_leaf_element.transaction_signature.0.push(Felt::ZERO); + } + tx_leaf_element + }) + .collect(); let transaction_commitment = calculate_transaction_commitment::(&transaction_leaf_elements); diff --git a/crates/starknet_api/src/block_hash/block_hash_calculator_test.rs b/crates/starknet_api/src/block_hash/block_hash_calculator_test.rs index e0685d82696..d8e1ba06f25 100644 --- a/crates/starknet_api/src/block_hash/block_hash_calculator_test.rs +++ b/crates/starknet_api/src/block_hash/block_hash_calculator_test.rs @@ -97,8 +97,12 @@ fn test_block_hash_regression( }]; let state_diff = get_state_diff(); - let block_commitments = - calculate_block_commitments(&transactions_data, &state_diff, block_header.l1_da_mode); + let block_commitments = calculate_block_commitments( + &transactions_data, + &state_diff, + block_header.l1_da_mode, + &block_hash_version.to_owned().into(), + ); let expected_hash = match block_hash_version { BlockHashVersion::VO_13_2 => { From 2c9e09aa4884c92ca11d177ff2081cb428b3a2ca Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Tue, 8 Oct 2024 14:42:59 +0300 Subject: [PATCH 08/57] fix(ci): committer CLI workflow concurrency error (#1256) Signed-off-by: Dori Medini --- .github/workflows/committer_cli_push.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/committer_cli_push.yml b/.github/workflows/committer_cli_push.yml index 87ab28fbc93..8475728b120 100644 --- a/.github/workflows/committer_cli_push.yml +++ b/.github/workflows/committer_cli_push.yml @@ -36,8 +36,8 @@ on: # On PR events, cancel existing CI runs on this same PR for this workflow. concurrency: - group: ${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: ${{ github.event_name == 'pull_request' }}-${{ github.job }} + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.job }} + cancel-in-progress: ${{ github.event_name == 'pull_request' }} jobs: gcs-push: From 1b7252f8a30244d39614d7666aa113b81291808e Mon Sep 17 00:00:00 2001 From: yoavGrs <97383386+yoavGrs@users.noreply.github.com> Date: Tue, 8 Oct 2024 15:38:40 +0300 Subject: [PATCH 09/57] feat(starknet_api): bump block hash constant prefix (#1244) --- crates/committer_cli/src/main.rs | 3 +- .../src/block_hash/block_hash_calculator.rs | 53 +++++++++++++++---- .../block_hash/block_hash_calculator_test.rs | 19 ++++--- crates/starknet_api/src/lib.rs | 5 ++ 4 files changed, 60 insertions(+), 20 deletions(-) diff --git a/crates/committer_cli/src/main.rs b/crates/committer_cli/src/main.rs index 43040f61946..4cb7116bfb4 100644 --- a/crates/committer_cli/src/main.rs +++ b/crates/committer_cli/src/main.rs @@ -91,7 +91,8 @@ async fn main() { let block_hash_input: BlockHashInput = load_from_stdin(); info!("Successfully loaded block hash input."); let block_hash = - calculate_block_hash(block_hash_input.header, block_hash_input.block_commitments); + calculate_block_hash(block_hash_input.header, block_hash_input.block_commitments) + .unwrap_or_else(|error| panic!("Failed to calculate block hash: {}", error)); write_to_file(&output_path, &block_hash); info!("Successfully computed block hash {:?}.", block_hash); } diff --git a/crates/starknet_api/src/block_hash/block_hash_calculator.rs b/crates/starknet_api/src/block_hash/block_hash_calculator.rs index a74555f1304..fe5381d7f06 100644 --- a/crates/starknet_api/src/block_hash/block_hash_calculator.rs +++ b/crates/starknet_api/src/block_hash/block_hash_calculator.rs @@ -28,6 +28,7 @@ use crate::transaction::{ TransactionHash, TransactionSignature, }; +use crate::{StarknetApiError, StarknetApiResult}; #[cfg(test)] #[path = "block_hash_calculator_test.rs"] @@ -36,12 +37,15 @@ mod block_hash_calculator_test; static STARKNET_BLOCK_HASH0: LazyLock = LazyLock::new(|| { ascii_as_felt("STARKNET_BLOCK_HASH0").expect("ascii_as_felt failed for 'STARKNET_BLOCK_HASH0'") }); +static STARKNET_BLOCK_HASH1: LazyLock = LazyLock::new(|| { + ascii_as_felt("STARKNET_BLOCK_HASH1").expect("ascii_as_felt failed for 'STARKNET_BLOCK_HASH1'") +}); static STARKNET_GAS_PRICES0: LazyLock = LazyLock::new(|| { ascii_as_felt("STARKNET_GAS_PRICES0").expect("ascii_as_felt failed for 'STARKNET_GAS_PRICES0'") }); #[allow(non_camel_case_types)] -#[derive(Clone, Debug, PartialEq, Eq)] +#[derive(Clone, Debug, PartialEq, Eq, PartialOrd)] pub enum BlockHashVersion { VO_13_2, VO_13_3, @@ -50,8 +54,34 @@ pub enum BlockHashVersion { impl From for StarknetVersion { fn from(value: BlockHashVersion) -> Self { match value { - BlockHashVersion::VO_13_2 => Self(vec![0, 13, 2]), - BlockHashVersion::VO_13_3 => Self(vec![0, 13, 3]), + BlockHashVersion::VO_13_2 => StarknetVersion(vec![0, 13, 2]), + BlockHashVersion::VO_13_3 => StarknetVersion(vec![0, 13, 3]), + } + } +} + +impl TryFrom for BlockHashVersion { + type Error = StarknetApiError; + + fn try_from(value: StarknetVersion) -> StarknetApiResult { + if value < Self::VO_13_2.into() { + Err(StarknetApiError::BlockHashVersion { version: value.to_string() }) + } else if value < Self::VO_13_3.into() { + Ok(Self::VO_13_2) + } else { + Ok(Self::VO_13_3) + } + } +} + +// The prefix constant for the block hash calculation. +type BlockHashConstant = Felt; + +impl From for BlockHashConstant { + fn from(block_hash_version: BlockHashVersion) -> Self { + match block_hash_version { + BlockHashVersion::VO_13_2 => *STARKNET_BLOCK_HASH0, + BlockHashVersion::VO_13_3 => *STARKNET_BLOCK_HASH1, } } } @@ -84,17 +114,18 @@ pub struct BlockHeaderCommitments { } /// Poseidon ( -/// “STARKNET_BLOCK_HASH0”, block_number, global_state_root, sequencer_address, +/// block_hash_constant, block_number, global_state_root, sequencer_address, /// block_timestamp, concat_counts, state_diff_hash, transaction_commitment, /// event_commitment, receipt_commitment, gas_prices, starknet_version, 0, parent_block_hash /// ). pub fn calculate_block_hash( header: BlockHeaderWithoutHash, block_commitments: BlockHeaderCommitments, -) -> BlockHash { - BlockHash( +) -> StarknetApiResult { + let block_hash_version: BlockHashVersion = header.starknet_version.clone().try_into()?; + Ok(BlockHash( HashChain::new() - .chain(&STARKNET_BLOCK_HASH0) + .chain(&block_hash_version.clone().into()) .chain(&header.block_number.0.into()) .chain(&header.state_root.0) .chain(&header.sequencer.0) @@ -109,7 +140,7 @@ pub fn calculate_block_hash( &header.l1_gas_price, &header.l1_data_gas_price, &header.l2_gas_price, - &header.starknet_version, + &block_hash_version, ) .iter(), ) @@ -119,7 +150,7 @@ pub fn calculate_block_hash( .chain(&Felt::ZERO) .chain(&header.parent_hash.0) .get_poseidon_hash(), - ) + )) } /// Calculates the commitments of the transactions data for the block hash. @@ -215,9 +246,9 @@ fn gas_prices_to_hash( l1_gas_price: &GasPricePerToken, l1_data_gas_price: &GasPricePerToken, l2_gas_price: &GasPricePerToken, - starknet_version: &StarknetVersion, + block_hash_version: &BlockHashVersion, ) -> Vec { - if *starknet_version >= BlockHashVersion::VO_13_3.into() { + if block_hash_version >= &BlockHashVersion::VO_13_3 { vec![ HashChain::new() .chain(&STARKNET_GAS_PRICES0) diff --git a/crates/starknet_api/src/block_hash/block_hash_calculator_test.rs b/crates/starknet_api/src/block_hash/block_hash_calculator_test.rs index d8e1ba06f25..fa2754211f4 100644 --- a/crates/starknet_api/src/block_hash/block_hash_calculator_test.rs +++ b/crates/starknet_api/src/block_hash/block_hash_calculator_test.rs @@ -44,18 +44,19 @@ macro_rules! test_hash_changes { { let header = BlockHeaderWithoutHash { l1_da_mode: L1DataAvailabilityMode::Blob, + starknet_version: BlockHashVersion::VO_13_3.into(), $($header_field: $header_value),* }; let commitments = BlockHeaderCommitments { $($commitments_field: $commitments_value),* }; - let original_hash = calculate_block_hash(header.clone(), commitments.clone()); + let original_hash = calculate_block_hash(header.clone(), commitments.clone()).unwrap(); $( // Test changing the field in the header. let mut modified_header = header.clone(); modified_header.$header_field = Default::default(); - let new_hash = calculate_block_hash(modified_header, commitments.clone()); + let new_hash = calculate_block_hash(modified_header, commitments.clone()).unwrap(); assert_ne!(original_hash, new_hash, concat!("Hash should change when ", stringify!($header_field), " is modified")); )* @@ -63,7 +64,7 @@ macro_rules! test_hash_changes { // Test changing the field in the commitments. let mut modified_commitments = commitments.clone(); modified_commitments.$commitments_field = Default::default(); - let new_hash = calculate_block_hash(header.clone(), modified_commitments); + let new_hash = calculate_block_hash(header.clone(), modified_commitments).unwrap(); assert_ne!(original_hash, new_hash, concat!("Hash should change when ", stringify!($commitments_field), " is modified")); )* } @@ -87,7 +88,7 @@ fn test_block_hash_regression( price_in_wei: 9_u8.into(), }, l2_gas_price: GasPricePerToken { price_in_fri: 11_u8.into(), price_in_wei: 12_u8.into() }, - starknet_version: block_hash_version.to_owned().into(), + starknet_version: block_hash_version.clone().into(), parent_hash: BlockHash(Felt::from(11_u8)), }; let transactions_data = vec![TransactionHashingData { @@ -109,11 +110,14 @@ fn test_block_hash_regression( felt!("0xe248d6ce583f8fa48d1d401d4beb9ceced3733e38d8eacb0d8d3669a7d901c") } BlockHashVersion::VO_13_3 => { - felt!("0x65b653f5bc0939cdc39f98230affc8fbd1a01ea801e025271a4cfba912ba59a") + felt!("0x566c0aaa2bb5fbd7957224108f089100d58f1d8767dd2b53698e27efbf2a28b") } }; - assert_eq!(BlockHash(expected_hash), calculate_block_hash(block_header, block_commitments),); + assert_eq!( + BlockHash(expected_hash), + calculate_block_hash(block_header, block_commitments).unwrap() + ); } #[test] @@ -159,8 +163,7 @@ fn change_field_of_hash_input() { l2_gas_price: GasPricePerToken { price_in_fri: 1_u8.into(), price_in_wei: 1_u8.into() }, state_root: GlobalRoot(Felt::ONE), sequencer: SequencerContractAddress(ContractAddress::from(1_u128)), - timestamp: BlockTimestamp(1), - starknet_version: BlockHashVersion::VO_13_3.into() + timestamp: BlockTimestamp(1) }, BlockHeaderCommitments { transaction_commitment: TransactionCommitment(Felt::ONE), diff --git a/crates/starknet_api/src/lib.rs b/crates/starknet_api/src/lib.rs index 7cf6beee5a5..f4778496672 100644 --- a/crates/starknet_api/src/lib.rs +++ b/crates/starknet_api/src/lib.rs @@ -29,6 +29,9 @@ use serde_utils::InnerDeserializationError; // Note: if you need `Eq` see InnerDeserializationError's docstring. #[derive(thiserror::Error, Clone, Debug, PartialEq)] pub enum StarknetApiError { + /// An error when a starknet version is out of range. + #[error("Starknet version {version} is out of range for block hash calculation")] + BlockHashVersion { version: String }, /// Error in the inner deserialization of the node. #[error(transparent)] InnerDeserialization(#[from] InnerDeserializationError), @@ -44,3 +47,5 @@ pub enum StarknetApiError { #[error("NonzeroGasPrice cannot be zero.")] ZeroGasPrice, } + +pub type StarknetApiResult = Result; From c8a5b17b3036e1ac76134bd4f2c1d92d60739277 Mon Sep 17 00:00:00 2001 From: amosStarkware <88497213+amosStarkware@users.noreply.github.com> Date: Tue, 8 Oct 2024 16:56:05 +0300 Subject: [PATCH 10/57] chore(blockifier): added regression test for gas computation (#968) --- crates/blockifier/src/fee/fee_test.rs | 18 +- crates/blockifier/src/fee/gas_usage_test.rs | 194 +++++++++++++++++-- crates/blockifier/src/fee/receipt_test.rs | 2 - crates/blockifier/src/test_utils.rs | 15 ++ crates/blockifier/src/versioned_constants.rs | 5 +- 5 files changed, 199 insertions(+), 35 deletions(-) diff --git a/crates/blockifier/src/fee/fee_test.rs b/crates/blockifier/src/fee/fee_test.rs index bd7a310e2b1..a3b4c00b2d9 100644 --- a/crates/blockifier/src/fee/fee_test.rs +++ b/crates/blockifier/src/fee/fee_test.rs @@ -1,8 +1,5 @@ -use std::collections::HashMap; - use assert_matches::assert_matches; use cairo_vm::types::builtin_name::BuiltinName; -use cairo_vm::vm::runners::cairo_runner::ExecutionResources; use rstest::rstest; use starknet_api::block::NonzeroGasPrice; use starknet_api::execution_resources::GasAmount; @@ -19,6 +16,7 @@ use crate::test_utils::contracts::FeatureContract; use crate::test_utils::initial_test_state::test_state; use crate::test_utils::{ gas_vector_from_vm_usage, + get_vm_resource_usage, CairoVersion, BALANCE, DEFAULT_ETH_L1_DATA_GAS_PRICE, @@ -33,20 +31,6 @@ use crate::transaction::test_utils::{account_invoke_tx, all_resource_bounds, l1_ use crate::utils::{u128_from_usize, u64_from_usize}; use crate::versioned_constants::VersionedConstants; -fn get_vm_resource_usage() -> ExecutionResources { - ExecutionResources { - n_steps: 10000, - n_memory_holes: 0, - builtin_instance_counter: HashMap::from([ - (BuiltinName::pedersen, 10), - (BuiltinName::range_check, 24), - (BuiltinName::ecdsa, 1), - (BuiltinName::bitwise, 1), - (BuiltinName::poseidon, 1), - ]), - } -} - #[rstest] fn test_simple_get_vm_resource_usage( #[values(GasVectorComputationMode::NoL2Gas, GasVectorComputationMode::All)] diff --git a/crates/blockifier/src/fee/gas_usage_test.rs b/crates/blockifier/src/fee/gas_usage_test.rs index 12e65ae4178..b96f6ad2889 100644 --- a/crates/blockifier/src/fee/gas_usage_test.rs +++ b/crates/blockifier/src/fee/gas_usage_test.rs @@ -1,5 +1,9 @@ +use std::sync::Arc; + +use num_rational::Ratio; use pretty_assertions::assert_eq; use rstest::{fixture, rstest}; +use starknet_api::execution_resources::GasAmount; use starknet_api::invoke_tx_args; use starknet_api::transaction::{EventContent, EventData, EventKey, GasVectorComputationMode}; use starknet_types_core::felt::Felt; @@ -10,18 +14,75 @@ use crate::execution::call_info::{CallExecution, CallInfo, OrderedEvent}; use crate::fee::eth_gas_constants; use crate::fee::fee_utils::get_fee_by_gas_vector; use crate::fee::gas_usage::{get_da_gas_cost, get_message_segment_length}; -use crate::fee::resources::{GasVector, StarknetResources, StateResources}; +use crate::fee::resources::{ + ComputationResources, + GasVector, + StarknetResources, + StateResources, + TransactionResources, +}; use crate::state::cached_state::StateChangesCount; -use crate::test_utils::{DEFAULT_ETH_L1_DATA_GAS_PRICE, DEFAULT_ETH_L1_GAS_PRICE}; +use crate::test_utils::{ + get_vm_resource_usage, + DEFAULT_ETH_L1_DATA_GAS_PRICE, + DEFAULT_ETH_L1_GAS_PRICE, +}; use crate::transaction::objects::FeeType; use crate::transaction::test_utils::account_invoke_tx; use crate::utils::{u128_from_usize, u64_from_usize}; -use crate::versioned_constants::{ResourceCost, VersionedConstants}; +use crate::versioned_constants::{ + ResourceCost, + StarknetVersion, + VersionedConstants, + VmResourceCosts, +}; + +pub fn create_event_for_testing(keys_size: usize, data_size: usize) -> OrderedEvent { + OrderedEvent { + order: 0, + event: EventContent { + keys: vec![EventKey(Felt::ZERO); keys_size], + data: EventData(vec![Felt::ZERO; data_size]), + }, + } +} + #[fixture] fn versioned_constants() -> &'static VersionedConstants { VersionedConstants::latest_constants() } +// Starknet resources with many resources (of arbitrary values) for testing. +#[fixture] +fn starknet_resources() -> StarknetResources { + let call_info_1 = CallInfo { + execution: CallExecution { + events: vec![create_event_for_testing(1, 2), create_event_for_testing(1, 2)], + ..Default::default() + }, + ..Default::default() + }; + let call_info_2 = CallInfo { + execution: CallExecution { + events: vec![create_event_for_testing(1, 0), create_event_for_testing(0, 1)], + ..Default::default() + }, + ..Default::default() + }; + let call_infos: Vec = vec![call_info_1, call_info_2] + .into_iter() + .map(|call_info| call_info.with_some_class_hash()) + .collect(); + let execution_summary = CallInfo::summarize_many(call_infos.iter()); + let state_resources = StateResources::new_for_testing(StateChangesCount { + n_storage_updates: 7, + n_class_hash_updates: 11, + n_compiled_class_hash_updates: 13, + n_modified_contracts: 17, + }); + StarknetResources::new(2_usize, 3_usize, 4_usize, state_resources, 6.into(), execution_summary) +} + #[rstest] fn test_get_event_gas_cost( versioned_constants: &VersionedConstants, @@ -50,32 +111,31 @@ fn test_get_event_gas_cost( ) ); - let create_event = |keys_size: usize, data_size: usize| OrderedEvent { - order: 0, - event: EventContent { - keys: vec![EventKey(Felt::ZERO); keys_size], - data: EventData(vec![Felt::ZERO; data_size]), - }, - }; let call_info_1 = CallInfo { execution: CallExecution { - events: vec![create_event(1, 2), create_event(1, 2)], + events: vec![create_event_for_testing(1, 2), create_event_for_testing(1, 2)], ..Default::default() }, ..Default::default() }; let call_info_2 = CallInfo { execution: CallExecution { - events: vec![create_event(1, 0), create_event(0, 1)], + events: vec![create_event_for_testing(1, 0), create_event_for_testing(0, 1)], ..Default::default() }, ..Default::default() }; let call_info_3 = CallInfo { - execution: CallExecution { events: vec![create_event(0, 1)], ..Default::default() }, + execution: CallExecution { + events: vec![create_event_for_testing(0, 1)], + ..Default::default() + }, inner_calls: vec![ CallInfo { - execution: CallExecution { events: vec![create_event(5, 5)], ..Default::default() }, + execution: CallExecution { + events: vec![create_event_for_testing(5, 5)], + ..Default::default() + }, ..Default::default() } .with_some_class_hash(), @@ -246,3 +306,109 @@ fn test_discounted_gas_from_gas_vector_computation() { <= actual_result.nonzero_checked_mul(DEFAULT_ETH_L1_GAS_PRICE).unwrap() ); } + +#[rstest] +// Assert gas computation results are as expected. The goal of this test is to prevent unwanted +// changes to the gas computation. +fn test_gas_computation_regression_test( + starknet_resources: StarknetResources, + #[values(false, true)] use_kzg_da: bool, + #[values(GasVectorComputationMode::NoL2Gas, GasVectorComputationMode::All)] + gas_vector_computation_mode: GasVectorComputationMode, +) { + // Use a constant version of the versioned constants so that version changes do not break this + // test. This specific version is arbitrary. + // TODO(Amos, 1/10/2024): Parameterize the version. + let mut versioned_constants = VersionedConstants::get(StarknetVersion::V0_13_2_1).clone(); + + // Change the VM resource fee cost so that the L2 / L1 gas ratio is a fraction. + let vm_resource_fee_cost = VmResourceCosts { + builtins: versioned_constants.vm_resource_fee_cost.builtins.clone(), + n_steps: Ratio::new(30, 10000), + }; + versioned_constants.vm_resource_fee_cost = Arc::new(vm_resource_fee_cost); + + // Test Starknet resources. + let actual_starknet_resources_gas_vector = starknet_resources.to_gas_vector( + &versioned_constants, + use_kzg_da, + &gas_vector_computation_mode, + ); + let expected_starknet_resources_gas_vector = match gas_vector_computation_mode { + GasVectorComputationMode::NoL2Gas => match use_kzg_da { + true => GasVector { + l1_gas: GasAmount(21544), + l1_data_gas: GasAmount(2720), + l2_gas: GasAmount(0), + }, + false => GasVector::from_l1_gas(GasAmount(62835)), + }, + GasVectorComputationMode::All => match use_kzg_da { + true => GasVector { + l1_gas: GasAmount(21543), + l1_data_gas: GasAmount(2720), + l2_gas: GasAmount(87040), + }, + false => GasVector { + l1_gas: GasAmount(62834), + l1_data_gas: GasAmount(0), + l2_gas: GasAmount(87040), + }, + }, + }; + assert_eq!( + actual_starknet_resources_gas_vector, expected_starknet_resources_gas_vector, + "Unexpected gas computation result for starknet resources. If this is intentional please \ + fix this test." + ); + + // Test VM resources. + let mut vm_resources = get_vm_resource_usage(); + vm_resources.n_memory_holes = 2; + let n_reverted_steps = 15; + let computation_resources = ComputationResources { vm_resources, n_reverted_steps }; + let actual_computation_resources_gas_vector = + computation_resources.to_gas_vector(&versioned_constants, &gas_vector_computation_mode); + let expected_computation_resources_gas_vector = match gas_vector_computation_mode { + GasVectorComputationMode::NoL2Gas => GasVector::from_l1_gas(GasAmount(31)), + GasVectorComputationMode::All => GasVector::from_l2_gas(GasAmount(1033334)), + }; + assert_eq!( + actual_computation_resources_gas_vector, expected_computation_resources_gas_vector, + "Unexpected gas computation result for VM resources. If this is intentional please fix \ + this test." + ); + + // Test transaction resources + let tx_resources = + TransactionResources { starknet_resources, computation: computation_resources }; + let actual_gas_vector = + tx_resources.to_gas_vector(&versioned_constants, use_kzg_da, &gas_vector_computation_mode); + let expected_gas_vector = match gas_vector_computation_mode { + GasVectorComputationMode::NoL2Gas => match use_kzg_da { + true => GasVector { + l1_gas: GasAmount(21575), + l1_data_gas: GasAmount(2720), + l2_gas: GasAmount(0), + }, + false => GasVector::from_l1_gas(GasAmount(62866)), + }, + GasVectorComputationMode::All => match use_kzg_da { + true => GasVector { + l1_gas: GasAmount(21543), + l1_data_gas: GasAmount(2720), + l2_gas: GasAmount(1120374), + }, + false => GasVector { + l1_gas: GasAmount(62834), + l1_data_gas: GasAmount(0), + l2_gas: GasAmount(1120374), + }, + }, + }; + assert_eq!( + actual_gas_vector, expected_gas_vector, + "Unexpected gas computation result for tx resources. If this is intentional please fix \ + this test." + ); +} diff --git a/crates/blockifier/src/fee/receipt_test.rs b/crates/blockifier/src/fee/receipt_test.rs index 3d37685f015..2b46e92d9ab 100644 --- a/crates/blockifier/src/fee/receipt_test.rs +++ b/crates/blockifier/src/fee/receipt_test.rs @@ -340,8 +340,6 @@ fn test_calculate_tx_gas_usage_basic<'a>( // Test that we exclude the fee token contract modification and adds the account’s balance change // in the state changes. -// TODO(Nimrod, 1/5/2024): Test regression w.r.t. all resources (including VM). (Only starknet -// resources are taken into account). #[rstest] fn test_calculate_tx_gas_usage( #[values(false, true)] use_kzg_da: bool, diff --git a/crates/blockifier/src/test_utils.rs b/crates/blockifier/src/test_utils.rs index af8e837997b..efa7cdc67e6 100644 --- a/crates/blockifier/src/test_utils.rs +++ b/crates/blockifier/src/test_utils.rs @@ -12,6 +12,7 @@ use std::collections::HashMap; use std::fs; use std::path::PathBuf; +use cairo_vm::types::builtin_name::BuiltinName; use cairo_vm::vm::runners::cairo_runner::ExecutionResources; use starknet_api::block::{GasPrice, NonzeroGasPrice}; use starknet_api::core::{ClassHash, ContractAddress, PatriciaKey}; @@ -403,3 +404,17 @@ pub fn gas_vector_from_vm_usage( ), } } + +pub fn get_vm_resource_usage() -> ExecutionResources { + ExecutionResources { + n_steps: 10000, + n_memory_holes: 0, + builtin_instance_counter: HashMap::from([ + (BuiltinName::pedersen, 10), + (BuiltinName::range_check, 24), + (BuiltinName::ecdsa, 1), + (BuiltinName::bitwise, 1), + (BuiltinName::poseidon, 1), + ]), + } +} diff --git a/crates/blockifier/src/versioned_constants.rs b/crates/blockifier/src/versioned_constants.rs index 9b846d190b3..f31fc2781b6 100644 --- a/crates/blockifier/src/versioned_constants.rs +++ b/crates/blockifier/src/versioned_constants.rs @@ -199,11 +199,12 @@ pub struct VersionedConstants { // See the struct's docstring for more details. pub os_constants: Arc, + // Fee related. + pub(crate) vm_resource_fee_cost: Arc, + // Resources. os_resources: Arc, - // Fee related. - vm_resource_fee_cost: Arc, // Just to make sure the value exists, but don't use the actual values. #[allow(dead_code)] gateway: serde::de::IgnoredAny, From 8fb3b7383e4f5ee54c4f7cbe3089e4568c0b8ccd Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Tue, 8 Oct 2024 16:59:39 +0300 Subject: [PATCH 11/57] feat(blockifier): compute fee from new gas vector (#1114) Signed-off-by: Dori Medini --- crates/blockifier/src/context.rs | 9 ++- crates/blockifier/src/fee/fee_test.rs | 6 +- crates/blockifier/src/fee/fee_utils.rs | 5 +- crates/blockifier/src/fee/resources.rs | 55 +++++++-------- .../transaction/account_transactions_test.rs | 70 +++++++++++++------ .../blockifier/src/transaction/test_utils.rs | 8 ++- crates/starknet_api/src/transaction.rs | 11 +++ 7 files changed, 100 insertions(+), 64 deletions(-) diff --git a/crates/blockifier/src/context.rs b/crates/blockifier/src/context.rs index 253ea3a4eec..753309645a0 100644 --- a/crates/blockifier/src/context.rs +++ b/crates/blockifier/src/context.rs @@ -4,7 +4,7 @@ use papyrus_config::dumping::{append_sub_config_name, ser_param, SerializeConfig use papyrus_config::{ParamPath, ParamPrivacyInput, SerializedParam}; use serde::{Deserialize, Serialize}; use starknet_api::core::{ChainId, ContractAddress}; -use starknet_api::transaction::{GasVectorComputationMode, ValidResourceBounds}; +use starknet_api::transaction::GasVectorComputationMode; use crate::blockifier::block::BlockInfo; use crate::bouncer::BouncerConfig; @@ -31,10 +31,9 @@ impl TransactionContext { } pub fn get_gas_vector_computation_mode(&self) -> GasVectorComputationMode { match &self.tx_info { - TransactionInfo::Current(info) => match info.resource_bounds { - ValidResourceBounds::AllResources(_) => GasVectorComputationMode::All, - ValidResourceBounds::L1Gas(_) => GasVectorComputationMode::NoL2Gas, - }, + TransactionInfo::Current(info) => { + info.resource_bounds.get_gas_vector_computation_mode() + } TransactionInfo::Deprecated(_) => GasVectorComputationMode::NoL2Gas, } } diff --git a/crates/blockifier/src/fee/fee_test.rs b/crates/blockifier/src/fee/fee_test.rs index a3b4c00b2d9..ad06c097a5e 100644 --- a/crates/blockifier/src/fee/fee_test.rs +++ b/crates/blockifier/src/fee/fee_test.rs @@ -291,8 +291,10 @@ fn test_post_execution_gas_overdraft_all_resource_bounds( #[rstest] #[case::happy_flow_l1_gas_only(10, 0, 0, 10, 2*10)] #[case::happy_flow_no_l2_gas(10, 20, 0, 10 + 3*20, 2*10 + 4*20)] -#[case::saturating_l1_gas(u128::MAX, 1, 0, u128::MAX, u128::MAX)] -#[case::saturating_l1_data_gas(1, u128::MAX, 0, u128::MAX, u128::MAX)] +#[case::happy_flow_all(10, 20, 30, 10 + 3*20 + 5*30, 2*10 + 4*20 + 6*30)] +#[case::saturating_l1_gas(u128::MAX, 1, 1, u128::MAX, u128::MAX)] +#[case::saturating_l1_data_gas(1, u128::MAX, 1, u128::MAX, u128::MAX)] +#[case::saturating_l2_gas(1, 1, u128::MAX, u128::MAX, u128::MAX)] fn test_get_fee_by_gas_vector_regression( #[case] l1_gas: u128, #[case] l1_data_gas: u128, diff --git a/crates/blockifier/src/fee/fee_utils.rs b/crates/blockifier/src/fee/fee_utils.rs index 3a622135285..e7d34530c65 100644 --- a/crates/blockifier/src/fee/fee_utils.rs +++ b/crates/blockifier/src/fee/fee_utils.rs @@ -79,10 +79,7 @@ pub fn get_fee_by_gas_vector( gas_vector: GasVector, fee_type: &FeeType, ) -> Fee { - gas_vector.saturated_cost( - block_info.gas_prices.get_l1_gas_price_by_fee_type(fee_type).into(), - block_info.gas_prices.get_l1_data_gas_price_by_fee_type(fee_type).into(), - ) + gas_vector.saturated_cost(&block_info.gas_prices.get_gas_prices_by_fee_type(fee_type)) } /// Returns the current fee balance and a boolean indicating whether the balance covers the fee. diff --git a/crates/blockifier/src/fee/resources.rs b/crates/blockifier/src/fee/resources.rs index 0ded29654bb..2a111b22eed 100644 --- a/crates/blockifier/src/fee/resources.rs +++ b/crates/blockifier/src/fee/resources.rs @@ -1,10 +1,10 @@ use cairo_vm::vm::runners::cairo_runner::ExecutionResources; use serde::Serialize; -use starknet_api::block::GasPrice; use starknet_api::core::ContractAddress; use starknet_api::execution_resources::GasAmount; -use starknet_api::transaction::{Fee, GasVectorComputationMode}; +use starknet_api::transaction::{Fee, GasVectorComputationMode, Resource}; +use crate::blockifier::block::GasPricesForFeeType; use crate::context::TransactionContext; use crate::execution::call_info::{EventSummary, ExecutionSummary}; use crate::fee::eth_gas_constants; @@ -317,40 +317,35 @@ impl GasVector { } /// Computes the cost (in fee token units) of the gas vector (saturating on overflow). - pub fn saturated_cost(&self, gas_price: GasPrice, blob_gas_price: GasPrice) -> Fee { - let l1_gas_cost = self - .l1_gas - .checked_mul(gas_price) - .unwrap_or_else(|| { + pub fn saturated_cost(&self, gas_prices: &GasPricesForFeeType) -> Fee { + let mut sum = Fee(0); + for (gas, price, resource) in [ + (self.l1_gas, gas_prices.l1_gas_price, Resource::L1Gas), + (self.l1_data_gas, gas_prices.l1_data_gas_price, Resource::L1DataGas), + (self.l2_gas, gas_prices.l2_gas_price, Resource::L2Gas), + ] { + let cost = gas.checked_mul(price.get()).unwrap_or_else(|| { log::warn!( - "L1 gas cost overflowed: multiplication of {} by {} resulted in overflow.", - self.l1_gas, - gas_price + "{} cost overflowed: multiplication of gas amount ({}) by price per unit ({}) \ + resulted in overflow.", + resource, + gas, + price ); Fee(u128::MAX) - }) - .0; - let l1_data_gas_cost = self - .l1_data_gas - .checked_mul(blob_gas_price) - .unwrap_or_else(|| { + }); + sum = sum.checked_add(cost).unwrap_or_else(|| { log::warn!( - "L1 blob gas cost overflowed: multiplication of {} by {} resulted in overflow.", - self.l1_data_gas, - blob_gas_price + "Total cost overflowed: addition of current sum ({}) and cost of {} ({}) \ + resulted in overflow.", + sum, + resource, + cost ); Fee(u128::MAX) - }) - .0; - let total = l1_gas_cost.checked_add(l1_data_gas_cost).unwrap_or_else(|| { - log::warn!( - "Total gas cost overflowed: addition of {} and {} resulted in overflow.", - l1_gas_cost, - l1_data_gas_cost - ); - u128::MAX - }); - Fee(total) + }); + } + sum } /// Compute l1_gas estimation from gas_vector using the following formula: diff --git a/crates/blockifier/src/transaction/account_transactions_test.rs b/crates/blockifier/src/transaction/account_transactions_test.rs index abaeba95927..4f6bd05e1b0 100644 --- a/crates/blockifier/src/transaction/account_transactions_test.rs +++ b/crates/blockifier/src/transaction/account_transactions_test.rs @@ -44,7 +44,7 @@ use crate::abi::abi_utils::{ selector_from_name, }; use crate::check_tx_execution_error_for_invalid_scenario; -use crate::context::BlockContext; +use crate::context::{BlockContext, TransactionContext}; use crate::execution::contract_class::{ContractClass, ContractClassV1}; use crate::execution::entry_point::EntryPointExecutionContext; use crate::execution::syscalls::SyscallSelector; @@ -74,7 +74,9 @@ use crate::transaction::test_utils::{ block_context, calculate_class_info_for_testing, create_account_tx_for_validate_test_nonce_0, + create_all_resource_bounds, create_test_init_data, + default_all_resource_bounds, deploy_and_fund_account, l1_resource_bounds, max_fee, @@ -392,16 +394,19 @@ fn test_infinite_recursion( } /// Tests that validation fails on insufficient steps if max fee is too low. -// TODO(Aner, 21/01/24) modify test for 4844. #[rstest] -#[case(TransactionVersion::ONE)] -#[case(TransactionVersion::THREE)] +#[case::v1(TransactionVersion::ONE, max_l1_resource_bounds())] +#[case::v3_l1_bounds_only(TransactionVersion::THREE, max_l1_resource_bounds())] +#[case::v3_all_bounds(TransactionVersion::THREE, default_all_resource_bounds())] fn test_max_fee_limit_validate( - block_context: BlockContext, + mut block_context: BlockContext, #[case] version: TransactionVersion, - max_l1_resource_bounds: ValidResourceBounds, + #[case] resource_bounds: ValidResourceBounds, + #[values(true, false)] use_kzg_da: bool, ) { + block_context.block_info.use_kzg_da = use_kzg_da; let chain_info = &block_context.chain_info; + let gas_computation_mode = resource_bounds.get_gas_vector_computation_mode(); let TestInitData { mut state, account_address, contract_address, mut nonce_manager } = create_test_init_data(chain_info, CairoVersion::Cairo1); let grindy_validate_account = FeatureContract::AccountWithLongValidate(CairoVersion::Cairo1); @@ -414,7 +419,7 @@ fn test_max_fee_limit_validate( declare_tx_args! { class_hash: grindy_class_hash, sender_address: account_address, - resource_bounds: max_l1_resource_bounds, + resource_bounds, nonce: nonce_manager.next(account_address), }, class_info, @@ -423,6 +428,9 @@ fn test_max_fee_limit_validate( // Deploy grindy account with a lot of grind in the constructor. // Expect this to fail without bumping nonce, so pass a temporary nonce manager. + // We want to test the block step bounds here - so set them to something low. + let old_validate_max_n_steps = block_context.versioned_constants.validate_max_n_steps; + block_context.versioned_constants.validate_max_n_steps = 1000; let mut ctor_grind_arg = felt!(1_u8); // Grind in deploy phase. let ctor_storage_arg = felt!(1_u8); // Not relevant for this test. let (deploy_account_tx, _) = deploy_and_fund_account( @@ -431,13 +439,14 @@ fn test_max_fee_limit_validate( chain_info, deploy_account_tx_args! { class_hash: grindy_class_hash, - resource_bounds: max_l1_resource_bounds, + resource_bounds, constructor_calldata: calldata![ctor_grind_arg, ctor_storage_arg], }, ); let error_trace = deploy_account_tx.execute(&mut state, &block_context, true, true).unwrap_err().to_string(); assert!(error_trace.contains("no remaining steps")); + block_context.versioned_constants.validate_max_n_steps = old_validate_max_n_steps; // Deploy grindy account successfully this time. ctor_grind_arg = felt!(0_u8); // Do not grind in deploy phase. @@ -447,7 +456,7 @@ fn test_max_fee_limit_validate( chain_info, deploy_account_tx_args! { class_hash: grindy_class_hash, - resource_bounds: max_l1_resource_bounds, + resource_bounds, constructor_calldata: calldata![ctor_grind_arg, ctor_storage_arg], }, ); @@ -467,15 +476,11 @@ fn test_max_fee_limit_validate( let account_tx = account_invoke_tx(invoke_tx_args! { // Temporary upper bounds; just for gas estimation. max_fee: MAX_FEE, - resource_bounds: max_l1_resource_bounds, + resource_bounds, ..tx_args.clone() }); - let estimated_min_gas_usage_vector = estimate_minimal_gas_vector( - &block_context, - &account_tx, - &GasVectorComputationMode::NoL2Gas, - ); - let estimated_min_l1_gas = estimated_min_gas_usage_vector.l1_gas; + let estimated_min_gas_usage_vector = + estimate_minimal_gas_vector(&block_context, &account_tx, &gas_computation_mode); let estimated_min_fee = get_fee_by_gas_vector(block_info, estimated_min_gas_usage_vector, &account_tx.fee_type()); @@ -484,12 +489,33 @@ fn test_max_fee_limit_validate( &block_context, invoke_tx_args! { max_fee: estimated_min_fee, - // TODO(Ori, 1/2/2024): Write an indicative expect message explaining why the conversion - // works. - resource_bounds: l1_resource_bounds( - estimated_min_l1_gas, - block_info.gas_prices.get_l1_gas_price_by_fee_type(&account_tx.fee_type()).into() - ), + resource_bounds: match resource_bounds.get_gas_vector_computation_mode() { + GasVectorComputationMode::NoL2Gas => { + // If KZG DA mode is active, the L1 gas amount in the minimal fee estimate does + // not include DA. To cover minimal cost with only an L1 gas bound, need to + // convert the L1 data gas to L1 gas. + let tx_context = TransactionContext { + block_context: block_context.clone(), + tx_info: account_tx.create_tx_info(), + }; + l1_resource_bounds( + estimated_min_gas_usage_vector.to_discounted_l1_gas(&tx_context), + block_info.gas_prices + .get_l1_gas_price_by_fee_type(&account_tx.fee_type()).into() + ) + } + GasVectorComputationMode::All => create_all_resource_bounds( + estimated_min_gas_usage_vector.l1_gas, + block_info.gas_prices + .get_l1_gas_price_by_fee_type(&account_tx.fee_type()).into(), + estimated_min_gas_usage_vector.l2_gas, + block_info.gas_prices + .get_l2_gas_price_by_fee_type(&account_tx.fee_type()).into(), + estimated_min_gas_usage_vector.l1_data_gas, + block_info.gas_prices + .get_l1_data_gas_price_by_fee_type(&account_tx.fee_type()).into(), + ), + }, ..tx_args }, ) diff --git a/crates/blockifier/src/transaction/test_utils.rs b/crates/blockifier/src/transaction/test_utils.rs index 7c6fa0e5506..b1ba7a91a7a 100644 --- a/crates/blockifier/src/transaction/test_utils.rs +++ b/crates/blockifier/src/transaction/test_utils.rs @@ -96,6 +96,11 @@ pub fn max_l1_resource_bounds() -> ValidResourceBounds { create_resource_bounds(&GasVectorComputationMode::NoL2Gas) } +#[fixture] +pub fn default_all_resource_bounds() -> ValidResourceBounds { + create_resource_bounds(&GasVectorComputationMode::All) +} + pub fn create_resource_bounds(computation_mode: &GasVectorComputationMode) -> ValidResourceBounds { match computation_mode { GasVectorComputationMode::NoL2Gas => { @@ -323,6 +328,7 @@ pub fn run_invoke_tx( /// Creates a `ResourceBoundsMapping` with the given `max_amount` and `max_price` for L1 gas limits. /// No guarantees on the values of the other resources bounds. +// TODO: Check usages of this function and update to using all gas bounds. pub fn l1_resource_bounds(max_amount: GasAmount, max_price: GasPrice) -> ValidResourceBounds { ValidResourceBounds::L1Gas(ResourceBounds { max_amount: max_amount.0.try_into().unwrap(), @@ -349,7 +355,7 @@ pub fn all_resource_bounds( ) } -fn create_all_resource_bounds( +pub fn create_all_resource_bounds( l1_max_amount: GasAmount, l1_max_price: GasPrice, l2_max_amount: GasAmount, diff --git a/crates/starknet_api/src/transaction.rs b/crates/starknet_api/src/transaction.rs index 984922569b8..3f1807b48fe 100644 --- a/crates/starknet_api/src/transaction.rs +++ b/crates/starknet_api/src/transaction.rs @@ -750,6 +750,10 @@ impl Fee { } result } + + pub fn checked_add(self, rhs: Fee) -> Option { + self.0.checked_add(rhs.0).map(Fee) + } } impl Div for Fee { @@ -1114,6 +1118,13 @@ impl ValidResourceBounds { }) } + pub fn get_gas_vector_computation_mode(&self) -> GasVectorComputationMode { + match self { + Self::AllResources(_) => GasVectorComputationMode::All, + Self::L1Gas(_) => GasVectorComputationMode::NoL2Gas, + } + } + // TODO(Nimrod): Default testing bounds should probably be AllResourceBounds variant. #[cfg(any(feature = "testing", test))] pub fn create_for_testing() -> Self { From 60146a3f7164467a330409899be7153c89038392 Mon Sep 17 00:00:00 2001 From: eitanm-starkware Date: Tue, 8 Oct 2024 14:46:04 +0300 Subject: [PATCH 12/57] chore(mempool_p2p): add gateway client to receiver --- Cargo.lock | 1 + crates/mempool_p2p/Cargo.toml | 1 + crates/mempool_p2p/src/receiver/mod.rs | 11 ++++++++++- 3 files changed, 12 insertions(+), 1 deletion(-) diff --git a/Cargo.lock b/Cargo.lock index 433ec090405..e60441e2ee4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10425,6 +10425,7 @@ dependencies = [ "async-trait", "papyrus_network", "papyrus_protobuf", + "starknet_gateway_types", "starknet_mempool_infra", "starknet_mempool_p2p_types", ] diff --git a/crates/mempool_p2p/Cargo.toml b/crates/mempool_p2p/Cargo.toml index 5fe3540ec7c..140d0011088 100644 --- a/crates/mempool_p2p/Cargo.toml +++ b/crates/mempool_p2p/Cargo.toml @@ -12,5 +12,6 @@ workspace = true async-trait.workspace = true papyrus_network.workspace = true papyrus_protobuf.workspace = true +starknet_gateway_types.workspace = true starknet_mempool_infra.workspace = true starknet_mempool_p2p_types.workspace = true diff --git a/crates/mempool_p2p/src/receiver/mod.rs b/crates/mempool_p2p/src/receiver/mod.rs index 9d5fdd92767..0aeeb2aedf0 100644 --- a/crates/mempool_p2p/src/receiver/mod.rs +++ b/crates/mempool_p2p/src/receiver/mod.rs @@ -4,6 +4,7 @@ use papyrus_network::network_manager::{ NetworkManager, }; use papyrus_protobuf::mempool::RpcTransactionWrapper; +use starknet_gateway_types::communication::SharedGatewayClient; use starknet_mempool_infra::component_definitions::ComponentStarter; pub struct MempoolP2pReceiver { @@ -13,6 +14,8 @@ pub struct MempoolP2pReceiver { broadcasted_messages_server: BroadcastTopicServer, #[allow(dead_code)] broadcast_messages_client: BroadcastTopicClient, + #[allow(dead_code)] + gateway_client: SharedGatewayClient, } impl MempoolP2pReceiver { @@ -20,8 +23,14 @@ impl MempoolP2pReceiver { network_manager: Option, broadcasted_messages_server: BroadcastTopicServer, broadcast_messages_client: BroadcastTopicClient, + gateway_client: SharedGatewayClient, ) -> Self { - Self { network_manager, broadcasted_messages_server, broadcast_messages_client } + Self { + network_manager, + broadcasted_messages_server, + broadcast_messages_client, + gateway_client, + } } } From 7daa3d768e839382519266928ebc7e4ce3578cf7 Mon Sep 17 00:00:00 2001 From: Arnon Hod Date: Wed, 9 Oct 2024 10:15:49 +0300 Subject: [PATCH 13/57] refactor: share the chain info as a config for the gateway (#520) --- config/mempool/default_config.json | 6 ++-- crates/gateway/src/config.rs | 24 +++---------- crates/gateway/src/gateway.rs | 15 ++++---- crates/gateway/src/gateway_test.rs | 4 ++- .../src/stateful_transaction_validator.rs | 5 +-- .../stateful_transaction_validator_test.rs | 34 ++++--------------- .../src/integration_test_utils.rs | 7 ++-- 7 files changed, 33 insertions(+), 62 deletions(-) diff --git a/config/mempool/default_config.json b/config/mempool/default_config.json index 2c94a560a01..b2065437427 100644 --- a/config/mempool/default_config.json +++ b/config/mempool/default_config.json @@ -304,17 +304,17 @@ "privacy": "Public", "value": 1 }, - "gateway_config.stateful_tx_validator_config.chain_info.chain_id": { + "gateway_config.chain_info.chain_id": { "description": "The chain ID of the StarkNet chain.", "privacy": "Public", "value": "0x0" }, - "gateway_config.stateful_tx_validator_config.chain_info.fee_token_addresses.eth_fee_token_address": { + "gateway_config.chain_info.fee_token_addresses.eth_fee_token_address": { "description": "Address of the ETH fee token.", "privacy": "Public", "value": "0x0" }, - "gateway_config.stateful_tx_validator_config.chain_info.fee_token_addresses.strk_fee_token_address": { + "gateway_config.chain_info.fee_token_addresses.strk_fee_token_address": { "description": "Address of the STRK fee token.", "privacy": "Public", "value": "0x0" diff --git a/crates/gateway/src/config.rs b/crates/gateway/src/config.rs index d2fb8267d57..ae5d025bda4 100644 --- a/crates/gateway/src/config.rs +++ b/crates/gateway/src/config.rs @@ -14,6 +14,7 @@ use crate::compiler_version::VersionId; pub struct GatewayConfig { pub stateless_tx_validator_config: StatelessTransactionValidatorConfig, pub stateful_tx_validator_config: StatefulTransactionValidatorConfig, + pub chain_info: ChainInfo, } impl SerializeConfig for GatewayConfig { @@ -27,6 +28,7 @@ impl SerializeConfig for GatewayConfig { self.stateful_tx_validator_config.dump(), "stateful_tx_validator_config", ), + append_sub_config_name(self.chain_info.dump(), "chain_info"), ] .into_iter() .flatten() @@ -139,9 +141,6 @@ pub struct StatefulTransactionValidatorConfig { pub max_nonce_for_validation_skip: Nonce, pub validate_max_n_steps: u32, pub max_recursion_depth: usize, - // TODO(Arni): Move this member out of the stateful transaction validator config. Move it into - // the gateway config. This is used during the transalation from external_tx to executable_tx. - pub chain_info: ChainInfo, } impl Default for StatefulTransactionValidatorConfig { @@ -150,14 +149,13 @@ impl Default for StatefulTransactionValidatorConfig { max_nonce_for_validation_skip: Nonce(Felt::ONE), validate_max_n_steps: 1_000_000, max_recursion_depth: 50, - chain_info: ChainInfo::default(), } } } impl SerializeConfig for StatefulTransactionValidatorConfig { fn dump(&self) -> BTreeMap { - let members = BTreeMap::from_iter([ + BTreeMap::from_iter([ ser_param( "max_nonce_for_validation_skip", &self.max_nonce_for_validation_skip, @@ -176,20 +174,6 @@ impl SerializeConfig for StatefulTransactionValidatorConfig { "Maximum recursion depth for nested calls during blockifier validation.", ParamPrivacyInput::Public, ), - ]); - let sub_configs = append_sub_config_name(self.chain_info.dump(), "chain_info"); - vec![members, sub_configs].into_iter().flatten().collect() - } -} - -impl StatefulTransactionValidatorConfig { - #[cfg(any(test, feature = "testing"))] - pub fn create_for_testing() -> Self { - StatefulTransactionValidatorConfig { - max_nonce_for_validation_skip: Default::default(), - validate_max_n_steps: 1000000, - max_recursion_depth: 50, - chain_info: ChainInfo::create_for_testing(), - } + ]) } } diff --git a/crates/gateway/src/gateway.rs b/crates/gateway/src/gateway.rs index b0c625b6d3f..4fcda507633 100644 --- a/crates/gateway/src/gateway.rs +++ b/crates/gateway/src/gateway.rs @@ -1,6 +1,7 @@ use std::clone::Clone; use std::sync::Arc; +use blockifier::context::ChainInfo; use starknet_api::executable_transaction::Transaction; use starknet_api::rpc_transaction::RpcTransaction; use starknet_api::transaction::TransactionHash; @@ -38,6 +39,7 @@ pub struct AppState { pub state_reader_factory: Arc, pub gateway_compiler: GatewayCompiler, pub mempool_client: SharedMempoolClient, + pub chain_info: ChainInfo, } impl Gateway { @@ -57,6 +59,7 @@ impl Gateway { state_reader_factory, gateway_compiler, mempool_client, + chain_info: config.chain_info.clone(), }; Gateway { config, app_state } } @@ -80,6 +83,7 @@ async fn internal_add_tx( app_state.stateful_tx_validator.as_ref(), app_state.state_reader_factory.as_ref(), app_state.gateway_compiler, + &app_state.chain_info, tx, ) }) @@ -105,6 +109,7 @@ fn process_tx( stateful_tx_validator: &StatefulTransactionValidator, state_reader_factory: &dyn StateReaderFactory, gateway_compiler: GatewayCompiler, + chain_info: &ChainInfo, tx: RpcTransaction, ) -> GatewayResult { // TODO(Arni, 1/5/2024): Perform congestion control. @@ -112,11 +117,8 @@ fn process_tx( // Perform stateless validations. stateless_tx_validator.validate(&tx)?; - let executable_tx = compile_contract_and_build_executable_tx( - tx, - &gateway_compiler, - &stateful_tx_validator.config.chain_info.chain_id, - )?; + let executable_tx = + compile_contract_and_build_executable_tx(tx, &gateway_compiler, &chain_info.chain_id)?; // Perfom post compilation validations. if let Transaction::Declare(executable_declare_tx) = &executable_tx { @@ -125,7 +127,8 @@ fn process_tx( } } - let mut validator = stateful_tx_validator.instantiate_validator(state_reader_factory)?; + let mut validator = + stateful_tx_validator.instantiate_validator(state_reader_factory, chain_info)?; let address = executable_tx.contract_address(); let nonce = validator.get_nonce(address).map_err(|e| { error!("Failed to get nonce for sender address {}: {}", address, e); diff --git a/crates/gateway/src/gateway_test.rs b/crates/gateway/src/gateway_test.rs index 955b1091149..fa2e0038e65 100644 --- a/crates/gateway/src/gateway_test.rs +++ b/crates/gateway/src/gateway_test.rs @@ -1,6 +1,7 @@ use std::sync::Arc; use assert_matches::assert_matches; +use blockifier::context::ChainInfo; use blockifier::test_utils::CairoVersion; use mempool_test_utils::starknet_api_test_utils::{declare_tx, invoke_tx}; use mockall::predicate::eq; @@ -28,13 +29,14 @@ pub fn app_state( config: StatelessTransactionValidatorConfig::default(), }, stateful_tx_validator: Arc::new(StatefulTransactionValidator { - config: StatefulTransactionValidatorConfig::create_for_testing(), + config: StatefulTransactionValidatorConfig::default(), }), gateway_compiler: GatewayCompiler::new_command_line_compiler( SierraToCasmCompilationConfig::default(), ), state_reader_factory: Arc::new(state_reader_factory), mempool_client, + chain_info: ChainInfo::create_for_testing(), } } diff --git a/crates/gateway/src/stateful_transaction_validator.rs b/crates/gateway/src/stateful_transaction_validator.rs index 60ab447c305..51694eb8682 100644 --- a/crates/gateway/src/stateful_transaction_validator.rs +++ b/crates/gateway/src/stateful_transaction_validator.rs @@ -4,7 +4,7 @@ use blockifier::blockifier::stateful_validator::{ StatefulValidatorResult as BlockifierStatefulValidatorResult, }; use blockifier::bouncer::BouncerConfig; -use blockifier::context::BlockContext; +use blockifier::context::{BlockContext, ChainInfo}; use blockifier::state::cached_state::CachedState; use blockifier::transaction::account_transaction::AccountTransaction; use blockifier::versioned_constants::VersionedConstants; @@ -88,6 +88,7 @@ impl StatefulTransactionValidator { pub fn instantiate_validator( &self, state_reader_factory: &dyn StateReaderFactory, + chain_info: &ChainInfo, ) -> StatefulTransactionValidatorResult { // TODO(yael 6/5/2024): consider storing the block_info as part of the // StatefulTransactionValidator and update it only once a new block is created. @@ -104,7 +105,7 @@ impl StatefulTransactionValidator { // able to read the block_hash of 10 blocks ago from papyrus. let block_context = BlockContext::new( block_info, - self.config.chain_info.clone(), + chain_info.clone(), versioned_constants, BouncerConfig::max(), ); diff --git a/crates/gateway/src/stateful_transaction_validator_test.rs b/crates/gateway/src/stateful_transaction_validator_test.rs index 76feed69619..1a12cde10ba 100644 --- a/crates/gateway/src/stateful_transaction_validator_test.rs +++ b/crates/gateway/src/stateful_transaction_validator_test.rs @@ -2,7 +2,7 @@ use blockifier::blockifier::stateful_validator::{ StatefulValidatorError as BlockifierStatefulValidatorError, StatefulValidatorResult as BlockifierStatefulValidatorResult, }; -use blockifier::context::BlockContext; +use blockifier::context::ChainInfo; use blockifier::test_utils::CairoVersion; use blockifier::transaction::errors::{TransactionFeeError, TransactionPreValidationError}; use mempool_test_utils::starknet_api_test_utils::{ @@ -44,20 +44,8 @@ pub const STATEFUL_VALIDATOR_FEE_ERROR: BlockifierStatefulValidatorError = ); #[fixture] -fn block_context() -> BlockContext { - BlockContext::create_for_testing() -} - -#[fixture] -fn stateful_validator(block_context: BlockContext) -> StatefulTransactionValidator { - StatefulTransactionValidator { - config: StatefulTransactionValidatorConfig { - max_nonce_for_validation_skip: Default::default(), - validate_max_n_steps: block_context.versioned_constants().validate_max_n_steps, - max_recursion_depth: block_context.versioned_constants().max_recursion_depth, - chain_info: block_context.chain_info().clone(), - }, - } +fn stateful_validator() -> StatefulTransactionValidator { + StatefulTransactionValidator { config: StatefulTransactionValidatorConfig::default() } } // TODO(Arni): consider testing declare and deploy account. @@ -90,8 +78,8 @@ fn test_stateful_tx_validator( assert_eq!(result, expected_result_as_stateful_transaction_result); } -#[test] -fn test_instantiate_validator() { +#[rstest] +fn test_instantiate_validator(stateful_validator: StatefulTransactionValidator) { let state_reader_factory = local_test_state_reader_factory(CairoVersion::Cairo1, false); let mut mock_state_reader_factory = MockStateReaderFactory::new(); @@ -111,16 +99,8 @@ fn test_instantiate_validator() { .with(eq(latest_block)) .return_once(move |_| state_reader); - let block_context = &BlockContext::create_for_testing(); - let stateful_validator = StatefulTransactionValidator { - config: StatefulTransactionValidatorConfig { - max_nonce_for_validation_skip: Default::default(), - validate_max_n_steps: block_context.versioned_constants().validate_max_n_steps, - max_recursion_depth: block_context.versioned_constants().max_recursion_depth, - chain_info: block_context.chain_info().clone(), - }, - }; - let blockifier_validator = stateful_validator.instantiate_validator(&mock_state_reader_factory); + let blockifier_validator = stateful_validator + .instantiate_validator(&mock_state_reader_factory, &ChainInfo::create_for_testing()); assert!(blockifier_validator.is_ok()); } diff --git a/crates/tests-integration/src/integration_test_utils.rs b/crates/tests-integration/src/integration_test_utils.rs index 36118f02672..854910ddfab 100644 --- a/crates/tests-integration/src/integration_test_utils.rs +++ b/crates/tests-integration/src/integration_test_utils.rs @@ -1,6 +1,7 @@ use std::net::SocketAddr; use axum::body::Body; +use blockifier::context::ChainInfo; use mempool_test_utils::starknet_api_test_utils::rpc_tx_to_json; use papyrus_storage::StorageConfig; use reqwest::{Client, Response}; @@ -25,10 +26,10 @@ async fn create_gateway_config() -> GatewayConfig { max_signature_length: 2, ..Default::default() }; + let stateful_tx_validator_config = StatefulTransactionValidatorConfig::default(); + let chain_info = ChainInfo::create_for_testing(); - let stateful_tx_validator_config = StatefulTransactionValidatorConfig::create_for_testing(); - - GatewayConfig { stateless_tx_validator_config, stateful_tx_validator_config } + GatewayConfig { stateless_tx_validator_config, stateful_tx_validator_config, chain_info } } async fn create_http_server_config() -> HttpServerConfig { From 876810d9da9902dffd187f0cf5ba02b10bad6dc4 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 10:28:59 +0300 Subject: [PATCH 14/57] feat(blockifier): fix testing feature passthrough to starknet_api (#1254) Signed-off-by: Dori Medini --- crates/blockifier/Cargo.toml | 5 +++-- crates/blockifier/src/execution/entry_point_execution.rs | 3 +-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/crates/blockifier/Cargo.toml b/crates/blockifier/Cargo.toml index 028a6ef6ff6..6554a657d4f 100644 --- a/crates/blockifier/Cargo.toml +++ b/crates/blockifier/Cargo.toml @@ -12,7 +12,7 @@ workspace = true [features] concurrency = [] jemalloc = ["dep:tikv-jemallocator"] -testing = ["rand", "rstest"] +testing = ["rand", "rstest", "starknet_api/testing"] transaction_serde = [] # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html @@ -51,7 +51,7 @@ serde_json = { workspace = true, features = ["arbitrary_precision"] } sha2.workspace = true sha3.workspace = true starknet-types-core.workspace = true -starknet_api = { workspace = true, features = ["testing"] } +starknet_api.workspace = true strum.workspace = true strum_macros.workspace = true tempfile.workspace = true @@ -67,6 +67,7 @@ pretty_assertions.workspace = true rand.workspace = true regex.workspace = true rstest.workspace = true +starknet_api = { workspace = true, features = ["testing"] } test-case.workspace = true [[bench]] diff --git a/crates/blockifier/src/execution/entry_point_execution.rs b/crates/blockifier/src/execution/entry_point_execution.rs index 1464e806147..08ebbb2b790 100644 --- a/crates/blockifier/src/execution/entry_point_execution.rs +++ b/crates/blockifier/src/execution/entry_point_execution.rs @@ -10,7 +10,6 @@ use cairo_vm::vm::runners::builtin_runner::BuiltinRunner; use cairo_vm::vm::runners::cairo_runner::{CairoArg, CairoRunner, ExecutionResources}; use cairo_vm::vm::security::verify_secure_runner; use num_traits::{ToPrimitive, Zero}; -use starknet_api::felt; use starknet_types_core::felt::Felt; use crate::execution::call_info::{CallExecution, CallInfo, Retdata}; @@ -224,7 +223,7 @@ fn prepare_program_extra_data( // additional `ret` statement). let mut ptr = (runner.vm.get_pc() + contract_class.bytecode_length())?; // Push a `ret` opcode. - write_felt(&mut runner.vm, &mut ptr, felt!(0x208b7fff7fff7ffe_u128))?; + write_felt(&mut runner.vm, &mut ptr, Felt::from(0x208b7fff7fff7ffe_u128))?; // Push a pointer to the builtin cost segment. write_maybe_relocatable(&mut runner.vm, &mut ptr, builtin_cost_segment_start)?; From 4ec649755539474ecf225ad2c306454e45081b33 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 10:31:41 +0300 Subject: [PATCH 15/57] feat(blockifier): more informative 'tx too large' error in the bouncer (#1249) Signed-off-by: Dori Medini --- .../blockifier/transaction_executor_test.rs | 5 +- crates/blockifier/src/bouncer.rs | 58 +++++++++++++++++-- crates/blockifier/src/bouncer_test.rs | 51 ++++++++-------- crates/blockifier/src/transaction/errors.rs | 8 ++- .../src/transaction/transaction_execution.rs | 4 +- 5 files changed, 89 insertions(+), 37 deletions(-) diff --git a/crates/blockifier/src/blockifier/transaction_executor_test.rs b/crates/blockifier/src/blockifier/transaction_executor_test.rs index a3a1eb58394..955e5c830f2 100644 --- a/crates/blockifier/src/blockifier/transaction_executor_test.rs +++ b/crates/blockifier/src/blockifier/transaction_executor_test.rs @@ -249,8 +249,7 @@ fn test_l1_handler(block_context: BlockContext) { }, 7 )] -#[should_panic(expected = "TransactionExecutionError(TransactionTooLarge): Transaction size \ - exceeds the maximum block capacity.")] +#[should_panic(expected = "Transaction size exceeds the maximum block capacity.")] #[case::transaction_too_large(BouncerWeights::default(), 11)] fn test_bouncing(#[case] initial_bouncer_weights: BouncerWeights, #[case] n_events: usize) { @@ -321,7 +320,7 @@ fn test_execute_txs_bouncing() { assert_matches!( results[1].as_ref().unwrap_err(), TransactionExecutorError::TransactionExecutionError( - TransactionExecutionError::TransactionTooLarge + TransactionExecutionError::TransactionTooLarge { .. } ) ); assert!(results[2].is_ok()); diff --git a/crates/blockifier/src/bouncer.rs b/crates/blockifier/src/bouncer.rs index 4e778f94c25..039f3785788 100644 --- a/crates/blockifier/src/bouncer.rs +++ b/crates/blockifier/src/bouncer.rs @@ -55,6 +55,20 @@ impl BouncerConfig { pub fn has_room(&self, weights: BouncerWeights) -> bool { self.block_max_capacity.has_room(weights) } + + pub fn within_max_capacity_or_err( + &self, + weights: BouncerWeights, + ) -> TransactionExecutionResult<()> { + if self.block_max_capacity.has_room(weights) { + Ok(()) + } else { + Err(TransactionExecutionError::TransactionTooLarge { + max_capacity: Box::new(self.block_max_capacity), + tx_size: Box::new(weights), + }) + } + } } #[derive( @@ -105,6 +119,22 @@ impl BouncerWeights { } } +impl std::fmt::Display for BouncerWeights { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "BouncerWeights {{ gas: {}, n_steps: {}, message_segment_length: {}, n_events: {}, \ + state_diff_size: {}, builtin_count: {} }}", + self.gas, + self.n_steps, + self.message_segment_length, + self.n_events, + self.state_diff_size, + self.builtin_count + ) + } +} + #[derive( Clone, Copy, @@ -201,6 +231,26 @@ impl From for BuiltinCount { } } +impl std::fmt::Display for BuiltinCount { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "BuiltinCount {{ add_mod: {}, bitwise: {}, ecdsa: {}, ec_op: {}, keccak: {}, mul_mod: \ + {}, pedersen: {}, poseidon: {}, range_check: {}, range_check96: {} }}", + self.add_mod, + self.bitwise, + self.ecdsa, + self.ec_op, + self.keccak, + self.mul_mod, + self.pedersen, + self.poseidon, + self.range_check, + self.range_check96 + ) + } +} + #[derive(Debug, Default, PartialEq)] #[cfg_attr(test, derive(Clone))] pub struct Bouncer { @@ -348,7 +398,7 @@ pub fn get_particia_update_resources(n_visited_storage_entries: usize) -> Execut } } -pub fn verify_tx_weights_in_bounds( +pub fn verify_tx_weights_within_max_capacity( state_reader: &S, tx_execution_summary: &ExecutionSummary, tx_resources: &TransactionResources, @@ -363,9 +413,5 @@ pub fn verify_tx_weights_in_bounds( tx_state_changes_keys, )?; - if !bouncer_config.has_room(tx_weights) { - return Err(TransactionExecutionError::TransactionTooLarge); - } - - Ok(()) + bouncer_config.within_max_capacity_or_err(tx_weights) } diff --git a/crates/blockifier/src/bouncer_test.rs b/crates/blockifier/src/bouncer_test.rs index c61840abb25..d50ac766e95 100644 --- a/crates/blockifier/src/bouncer_test.rs +++ b/crates/blockifier/src/bouncer_test.rs @@ -1,19 +1,24 @@ use std::collections::{HashMap, HashSet}; +use assert_matches::assert_matches; use cairo_vm::types::builtin_name::BuiltinName; +use cairo_vm::vm::runners::cairo_runner::ExecutionResources; use rstest::rstest; use starknet_api::core::{ClassHash, ContractAddress, PatriciaKey}; use starknet_api::transaction::Fee; use starknet_api::{class_hash, contract_address, felt, patricia_key, storage_key}; use super::BouncerConfig; -use crate::blockifier::transaction_executor::{ - TransactionExecutorError, - TransactionExecutorResult, +use crate::blockifier::transaction_executor::TransactionExecutorError; +use crate::bouncer::{ + verify_tx_weights_within_max_capacity, + Bouncer, + BouncerWeights, + BuiltinCount, }; -use crate::bouncer::{verify_tx_weights_in_bounds, Bouncer, BouncerWeights, BuiltinCount}; use crate::context::BlockContext; use crate::execution::call_info::ExecutionSummary; +use crate::fee::resources::{ComputationResources, TransactionResources}; use crate::state::cached_state::{StateChangesKeys, TransactionalState}; use crate::test_utils::initial_test_state::test_state; use crate::transaction::errors::TransactionExecutionError; @@ -171,22 +176,10 @@ fn test_bouncer_update(#[case] initial_bouncer: Bouncer) { } #[rstest] -#[case::positive_flow(1, Ok(()))] -#[case::block_full(11, Err(TransactionExecutorError::BlockFull))] -#[case::transaction_too_large( - 21, - Err(TransactionExecutorError::TransactionExecutionError( - TransactionExecutionError::TransactionTooLarge - )) -)] -fn test_bouncer_try_update( - #[case] added_ecdsa: usize, - #[case] expected_result: TransactionExecutorResult<()>, -) { - use cairo_vm::vm::runners::cairo_runner::ExecutionResources; - - use crate::fee::resources::{ComputationResources, TransactionResources}; - +#[case::positive_flow(1, "ok")] +#[case::block_full(11, "block_full")] +#[case::transaction_too_large(21, "too_large")] +fn test_bouncer_try_update(#[case] added_ecdsa: usize, #[case] scenario: &'static str) { let state = &mut test_state(&BlockContext::create_for_account_testing().chain_info, Fee(0), &[]); let mut transactional_state = TransactionalState::create_transactional(state); @@ -249,7 +242,7 @@ fn test_bouncer_try_update( let tx_resources = TransactionResources { computation: ComputationResources { vm_resources: ExecutionResources { - builtin_instance_counter: builtin_counter, + builtin_instance_counter: builtin_counter.clone(), ..Default::default() }, ..Default::default() @@ -261,7 +254,7 @@ fn test_bouncer_try_update( // TODO(Yoni, 1/10/2024): simplify this test and move tx-too-large cases out. // Check that the transaction is not too large. - let mut result = verify_tx_weights_in_bounds( + let mut result = verify_tx_weights_within_max_capacity( &transactional_state, &execution_summary, &tx_resources, @@ -269,6 +262,8 @@ fn test_bouncer_try_update( &bouncer.bouncer_config, ) .map_err(TransactionExecutorError::TransactionExecutionError); + let expected_weights = + BouncerWeights { builtin_count: builtin_counter.into(), ..Default::default() }; if result.is_ok() { // Try to update the bouncer. @@ -280,6 +275,14 @@ fn test_bouncer_try_update( ); } - // TODO(yael 27/3/24): compare the results without using string comparison. - assert_eq!(format!("{:?}", result), format!("{:?}", expected_result)); + match scenario { + "ok" => assert_matches!(result, Ok(())), + "block_full" => assert_matches!(result, Err(TransactionExecutorError::BlockFull)), + "too_large" => assert_matches!(result, Err( + TransactionExecutorError::TransactionExecutionError( + TransactionExecutionError::TransactionTooLarge { max_capacity, tx_size } + ) + ) if *max_capacity == block_max_capacity && *tx_size == expected_weights), + _ => panic!("Unexpected scenario: {}", scenario), + } } diff --git a/crates/blockifier/src/transaction/errors.rs b/crates/blockifier/src/transaction/errors.rs index 804ada40fd7..6c2ae269d53 100644 --- a/crates/blockifier/src/transaction/errors.rs +++ b/crates/blockifier/src/transaction/errors.rs @@ -8,6 +8,7 @@ use starknet_api::StarknetApiError; use starknet_types_core::felt::FromStrError; use thiserror::Error; +use crate::bouncer::BouncerWeights; use crate::execution::call_info::Retdata; use crate::execution::errors::{ConstructorEntryPointExecutionError, EntryPointExecutionError}; use crate::execution::execution_utils::format_panic_data; @@ -122,8 +123,11 @@ pub enum TransactionExecutionError { TransactionPreValidationError(#[from] TransactionPreValidationError), #[error(transparent)] TryFromIntError(#[from] std::num::TryFromIntError), - #[error("Transaction size exceeds the maximum block capacity.")] - TransactionTooLarge, + #[error( + "Transaction size exceeds the maximum block capacity. Max block capacity: {}, \ + transaction size: {}.", *max_capacity, *tx_size + )] + TransactionTooLarge { max_capacity: Box, tx_size: Box }, #[error( "Transaction validation has failed:\n{}", String::from(gen_tx_execution_error_trace(self)) diff --git a/crates/blockifier/src/transaction/transaction_execution.rs b/crates/blockifier/src/transaction/transaction_execution.rs index c564896ea7a..aadfa71043e 100644 --- a/crates/blockifier/src/transaction/transaction_execution.rs +++ b/crates/blockifier/src/transaction/transaction_execution.rs @@ -4,7 +4,7 @@ use cairo_vm::vm::runners::cairo_runner::ExecutionResources; use starknet_api::core::{calculate_contract_address, ContractAddress, Nonce}; use starknet_api::transaction::{Fee, Transaction as StarknetApiTransaction, TransactionHash}; -use crate::bouncer::verify_tx_weights_in_bounds; +use crate::bouncer::verify_tx_weights_within_max_capacity; use crate::context::BlockContext; use crate::execution::call_info::CallInfo; use crate::execution::contract_class::ClassInfo; @@ -208,7 +208,7 @@ impl ExecutableTransaction for Transaction { &tx_execution_info, concurrency_mode, ); - verify_tx_weights_in_bounds( + verify_tx_weights_within_max_capacity( state, &tx_execution_summary, &tx_execution_info.receipt.resources, From 0bb8b5d178229f09e9b82a8f35a66c1c52fec557 Mon Sep 17 00:00:00 2001 From: matan-starkware <97523054+matan-starkware@users.noreply.github.com> Date: Wed, 9 Oct 2024 10:33:22 +0300 Subject: [PATCH 16/57] feat(consensus): add new context impl with just the build proposal flow (#1193) --- Cargo.lock | 5 + .../papyrus_consensus_orchestrator/Cargo.toml | 5 + .../papyrus_consensus_orchestrator/src/lib.rs | 2 + .../src/sequencer_consensus_context.rs | 213 ++++++++++++++++++ .../src/sequencer_consensus_context_test.rs | 68 ++++++ 5 files changed, 293 insertions(+) create mode 100644 crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context.rs create mode 100644 crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context_test.rs diff --git a/Cargo.lock b/Cargo.lock index e60441e2ee4..4e30e3092e1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -7292,14 +7292,19 @@ name = "papyrus_consensus_orchestrator" version = "0.0.0" dependencies = [ "async-trait", + "chrono", "futures", + "lazy_static", "mockall", "papyrus_consensus", "papyrus_network", "papyrus_protobuf", "papyrus_storage", "papyrus_test_utils", + "starknet-types-core", "starknet_api", + "starknet_batcher_types", + "starknet_consensus_manager_types", "test-case", "tokio", "tracing", diff --git a/crates/sequencing/papyrus_consensus_orchestrator/Cargo.toml b/crates/sequencing/papyrus_consensus_orchestrator/Cargo.toml index a053495dc36..067e8535c2e 100644 --- a/crates/sequencing/papyrus_consensus_orchestrator/Cargo.toml +++ b/crates/sequencing/papyrus_consensus_orchestrator/Cargo.toml @@ -8,16 +8,21 @@ description = "Implements the consensus context and orchestrates the node's comp [dependencies] async-trait.workspace = true +chrono.workspace = true futures.workspace = true papyrus_consensus.workspace = true papyrus_network.workspace = true papyrus_protobuf.workspace = true papyrus_storage.workspace = true +starknet-types-core.workspace = true starknet_api.workspace = true +starknet_batcher_types.workspace = true +starknet_consensus_manager_types.workspace = true tokio = { workspace = true, features = ["full"] } tracing.workspace = true [dev-dependencies] +lazy_static.workspace = true mockall.workspace = true papyrus_network = { workspace = true, features = ["testing"] } papyrus_storage = { workspace = true, features = ["testing"] } diff --git a/crates/sequencing/papyrus_consensus_orchestrator/src/lib.rs b/crates/sequencing/papyrus_consensus_orchestrator/src/lib.rs index 42666c0f910..ff7de38c704 100644 --- a/crates/sequencing/papyrus_consensus_orchestrator/src/lib.rs +++ b/crates/sequencing/papyrus_consensus_orchestrator/src/lib.rs @@ -5,3 +5,5 @@ #[allow(missing_docs)] // TODO: this is test code, rename accordingly. pub mod papyrus_consensus_context; +#[allow(missing_docs)] +pub mod sequencer_consensus_context; diff --git a/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context.rs b/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context.rs new file mode 100644 index 00000000000..95898bdddb2 --- /dev/null +++ b/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context.rs @@ -0,0 +1,213 @@ +//! Implementation of the ConsensusContext interface for running the sequencer. +//! +//! It connects to the Batcher who is responsible for building/validating blocks. +#[cfg(test)] +#[path = "sequencer_consensus_context_test.rs"] +mod sequencer_consensus_context_test; + +use std::collections::{BTreeMap, HashMap}; +use std::sync::{Arc, Mutex}; +use std::time::Duration; + +use async_trait::async_trait; +use futures::channel::{mpsc, oneshot}; +use futures::sink::SinkExt; +use papyrus_consensus::types::{ + ConsensusContext, + ConsensusError, + ProposalContentId, + ProposalInit, + Round, + ValidatorId, +}; +use papyrus_protobuf::consensus::{ConsensusMessage, Vote}; +use starknet_api::block::{BlockHash, BlockNumber}; +use starknet_api::executable_transaction::Transaction; +use starknet_batcher_types::batcher_types::{ + BuildProposalInput, + GetProposalContent, + GetProposalContentInput, +}; +use starknet_batcher_types::communication::BatcherClient; +use starknet_consensus_manager_types::consensus_manager_types::ProposalId; +use tracing::{debug, debug_span, warn, Instrument}; + +type HeightToIdToContent = BTreeMap>>; + +// Channel size for streaming proposal parts. +// TODO(matan): Consider making this configurable. May want to define `max_proposal_parts`. +const CHANNEL_SIZE: usize = 5000; + +pub struct SequencerConsensusContext { + batcher: Arc, + // Proposal building/validating returns immediately, leaving the actual processing to a spawned + // task. The spawned task processes the proposal asynchronously and updates the + // valid_proposals map upon completion, ensuring consistency across tasks. + valid_proposals: Arc>, + // Used to generate unique proposal IDs across the lifetime of the context. + // TODO(matan): Consider robustness in case consensus can restart without the Batcher + // restarting. + proposal_id: u64, +} + +impl SequencerConsensusContext { + pub fn new(batcher: Arc) -> Self { + Self { + batcher, + valid_proposals: Arc::new(Mutex::new(HeightToIdToContent::new())), + proposal_id: 0, + } + } +} + +#[async_trait] +impl ConsensusContext for SequencerConsensusContext { + // TODO: Switch to ProposalPart when Guy merges the PR. + type ProposalChunk = Vec; + + async fn build_proposal( + &mut self, + height: BlockNumber, + timeout: Duration, + ) -> (mpsc::Receiver, oneshot::Receiver) { + debug!("Building proposal for height: {height} with timeout: {timeout:?}"); + let (content_sender, content_receiver) = mpsc::channel(CHANNEL_SIZE); + let (fin_sender, fin_receiver) = oneshot::channel(); + + let batcher = Arc::clone(&self.batcher); + let valid_proposals = Arc::clone(&self.valid_proposals); + + let proposal_id = ProposalId(self.proposal_id); + self.proposal_id += 1; + let timeout = + chrono::Duration::from_std(timeout).expect("Can't convert timeout to chrono::Duration"); + let build_proposal_input = BuildProposalInput { + proposal_id, + // TODO: Discuss with batcher team passing std Duration instead. + deadline: chrono::Utc::now() + timeout, + // TODO: This is not part of Milestone 1. + retrospective_block_hash: None, + }; + // TODO: Should we be returning an error? + // I think this implies defining an error type in this crate and moving the trait definition + // here also. + batcher + .build_proposal(build_proposal_input) + .await + .expect("Failed to initiate proposal build"); + tokio::spawn( + async move { + stream_build_proposal( + height, + proposal_id, + batcher, + valid_proposals, + content_sender, + fin_sender, + ) + .await; + } + .instrument(debug_span!("consensus_build_proposal")), + ); + + (content_receiver, fin_receiver) + } + + async fn validate_proposal( + &mut self, + _height: BlockNumber, + _timeout: Duration, + _content: mpsc::Receiver, + ) -> oneshot::Receiver { + todo!() + } + + async fn get_proposal( + &self, + _height: BlockNumber, + _id: ProposalContentId, + ) -> mpsc::Receiver { + todo!() + } + + async fn validators(&self, _height: BlockNumber) -> Vec { + todo!() + } + + fn proposer(&self, _height: BlockNumber, _round: Round) -> ValidatorId { + todo!() + } + + async fn broadcast(&mut self, _message: ConsensusMessage) -> Result<(), ConsensusError> { + todo!() + } + + async fn propose( + &self, + _init: ProposalInit, + _content_receiver: mpsc::Receiver, + _fin_receiver: oneshot::Receiver, + ) -> Result<(), ConsensusError> { + todo!() + } + + async fn decision_reached( + &mut self, + _block: ProposalContentId, + _precommits: Vec, + ) -> Result<(), ConsensusError> { + todo!() + } +} + +// Handles building a new proposal without blocking consensus: +// 1. Receive chunks of content from the batcher. +// 2. Forward these to consensus to be streamed out to the network. +// 3. Once finished, receive the commitment from the batcher. +// 4. Store the proposal for re-proposal. +// 5. Send the commitment to consensus. +async fn stream_build_proposal( + height: BlockNumber, + proposal_id: ProposalId, + batcher: Arc, + valid_proposals: Arc>, + mut content_sender: mpsc::Sender>, + fin_sender: oneshot::Sender, +) { + let mut content = Vec::new(); + loop { + let response = + match batcher.get_proposal_content(GetProposalContentInput { proposal_id }).await { + Ok(response) => response, + Err(e) => { + warn!("Failed to get proposal content: {e:?}"); + return; + } + }; + match response.content { + GetProposalContent::Txs(txs) => { + content.extend_from_slice(&txs[..]); + // TODO(matan): Convert to protobuf and make sure this isn't too large for a single + // proto message (could this be a With adapter added to the channel in `new`?). + if let Err(e) = content_sender.send(txs).await { + // Consensus may exit early (e.g. sync). + warn!("Failed to send proposal content: {e:?}"); + // TODO: Discuss with the batcher team updating them of the abort. + break; + } + } + GetProposalContent::Finished(id) => { + let proposal_content_id = BlockHash(id.tx_commitment.0); + // Update valid_proposals before sending fin to avoid a race condition + // with `get_proposal` being called before `valid_proposals` is updated. + let mut valid_proposals = valid_proposals.lock().unwrap(); + valid_proposals.entry(height).or_default().insert(proposal_content_id, content); + if fin_sender.send(proposal_content_id).is_err() { + // Consensus may exit early (e.g. sync). + warn!("Failed to send proposal content id"); + } + return; + } + } + } +} diff --git a/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context_test.rs b/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context_test.rs new file mode 100644 index 00000000000..7e5d28f6015 --- /dev/null +++ b/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context_test.rs @@ -0,0 +1,68 @@ +use std::sync::{Arc, OnceLock}; +use std::time::Duration; +use std::vec; + +use futures::StreamExt; +use lazy_static::lazy_static; +use papyrus_consensus::types::ConsensusContext; +use starknet_api::block::BlockNumber; +use starknet_api::core::TransactionCommitment; +use starknet_api::executable_transaction::Transaction; +use starknet_api::test_utils::invoke::{executable_invoke_tx, InvokeTxArgs}; +use starknet_api::transaction::TransactionHash; +use starknet_batcher_types::batcher_types::{ + BuildProposalInput, + GetProposalContent, + GetProposalContentResponse, + ProposalCommitment, +}; +use starknet_batcher_types::communication::MockBatcherClient; +use starknet_types_core::felt::Felt; + +use crate::sequencer_consensus_context::SequencerConsensusContext; + +const TIMEOUT: Duration = Duration::from_millis(100); +const TX_COMMITMENT: TransactionCommitment = TransactionCommitment(Felt::ZERO); + +lazy_static! { + static ref TX_BATCH: Vec = vec![generate_invoke_tx(Felt::THREE)]; +} + +fn generate_invoke_tx(tx_hash: Felt) -> Transaction { + Transaction::Invoke(executable_invoke_tx(InvokeTxArgs { + tx_hash: TransactionHash(tx_hash), + ..Default::default() + })) +} + +#[tokio::test] +async fn build_proposal() { + let mut batcher = MockBatcherClient::new(); + let proposal_id = Arc::new(OnceLock::new()); + let proposal_id_clone = Arc::clone(&proposal_id); + batcher.expect_build_proposal().returning(move |input: BuildProposalInput| { + proposal_id_clone.set(input.proposal_id).unwrap(); + Ok(()) + }); + let proposal_id_clone = Arc::clone(&proposal_id); + batcher.expect_get_proposal_content().times(1).returning(move |input| { + assert_eq!(input.proposal_id, *proposal_id_clone.get().unwrap()); + Ok(GetProposalContentResponse { content: GetProposalContent::Txs(TX_BATCH.clone()) }) + }); + let proposal_id_clone = Arc::clone(&proposal_id); + batcher.expect_get_proposal_content().times(1).returning(move |input| { + assert_eq!(input.proposal_id, *proposal_id_clone.get().unwrap()); + Ok(GetProposalContentResponse { + content: GetProposalContent::Finished(ProposalCommitment { + tx_commitment: TX_COMMITMENT, + ..Default::default() + }), + }) + }); + let mut context = SequencerConsensusContext::new(Arc::new(batcher)); + let (mut content_receiver, fin_receiver) = + context.build_proposal(BlockNumber(0), TIMEOUT).await; + assert_eq!(content_receiver.next().await, Some(TX_BATCH.clone())); + assert!(content_receiver.next().await.is_none()); + assert_eq!(fin_receiver.await.unwrap().0, TX_COMMITMENT.0); +} From 8886d8cf9ed9448b35217814d02643719284d971 Mon Sep 17 00:00:00 2001 From: yoavGrs <97383386+yoavGrs@users.noreply.github.com> Date: Wed, 9 Oct 2024 10:59:46 +0300 Subject: [PATCH 17/57] test(blockifier): test tracked resource type (#1210) --- crates/blockifier/Cargo.toml | 1 + .../compiled/test_contract_compiled.json | 607 ++- .../cairo0/test_contract.cairo | 36 +- .../cairo1/compiled/test_contract.casm.json | 3827 +++++++++++------ .../cairo1/test_contract.cairo | 70 +- .../src/execution/stack_trace_test.rs | 20 +- .../syscalls/syscall_tests/call_contract.rs | 101 + 7 files changed, 3122 insertions(+), 1540 deletions(-) diff --git a/crates/blockifier/Cargo.toml b/crates/blockifier/Cargo.toml index 6554a657d4f..df7f032b12f 100644 --- a/crates/blockifier/Cargo.toml +++ b/crates/blockifier/Cargo.toml @@ -63,6 +63,7 @@ toml.workspace = true assert_matches.workspace = true criterion = { workspace = true, features = ["html_reports"] } glob.workspace = true +itertools.workspace = true pretty_assertions.workspace = true rand.workspace = true regex.workspace = true diff --git a/crates/blockifier/feature_contracts/cairo0/compiled/test_contract_compiled.json b/crates/blockifier/feature_contracts/cairo0/compiled/test_contract_compiled.json index 8b97584afbd..8e40ff3fde3 100644 --- a/crates/blockifier/feature_contracts/cairo0/compiled/test_contract_compiled.json +++ b/crates/blockifier/feature_contracts/cairo0/compiled/test_contract_compiled.json @@ -264,6 +264,54 @@ ], "type": "function" }, + { + "inputs": [ + { + "name": "contract_address_0", + "type": "felt" + }, + { + "name": "function_selector_0", + "type": "felt" + }, + { + "name": "calldata_0_len", + "type": "felt" + }, + { + "name": "calldata_0", + "type": "felt*" + }, + { + "name": "contract_address_1", + "type": "felt" + }, + { + "name": "function_selector_1", + "type": "felt" + }, + { + "name": "calldata_1_len", + "type": "felt" + }, + { + "name": "calldata_1", + "type": "felt*" + } + ], + "name": "test_call_two_contracts", + "outputs": [ + { + "name": "retdata_size", + "type": "felt" + }, + { + "name": "retdata", + "type": "felt*" + } + ], + "type": "function" + }, { "inputs": [ { @@ -660,23 +708,23 @@ ], "EXTERNAL": [ { - "offset": 1269, + "offset": 1344, "selector": "0x1143aa89c8e3ebf8ed14df2a3606c1cd2dd513fac8040b0f8ab441f5c52fe4" }, { - "offset": 1311, + "offset": 1386, "selector": "0x600c98a299d72ef1e09a2e1503206fbc76081233172c65f7e2438ef0069d8d" }, { - "offset": 1185, + "offset": 1260, "selector": "0x62c83572d28cb834a3de3c1e94977a4191469a4a8c26d1d7bc55305e640ed5" }, { - "offset": 1825, + "offset": 1900, "selector": "0x679c22735055a10db4f275395763a3752a1e3a3043c192299ab6b574fba8d6" }, { - "offset": 1749, + "offset": 1824, "selector": "0x7772be8b80a8a33dc6c1f9a6ab820c02e537c73e859de67f288c70f92571bb" }, { @@ -684,11 +732,11 @@ "selector": "0xad451bd0dba3d8d97104e1bfc474f88605ccc7acbe1c846839a120fdf30d95" }, { - "offset": 1575, + "offset": 1650, "selector": "0xd47144c49bce05b6de6bce9d5ff0cc8da9420f8945453e20ef779cbea13ad4" }, { - "offset": 928, + "offset": 1003, "selector": "0xe7510edcf6e9f1b70f7bd1f488767b50f0363422f3c563160ab77adf62467b" }, { @@ -700,11 +748,11 @@ "selector": "0x120c24672855cfe872cb35256ea85172417f2aada7a22c15908906dc5f3c69d" }, { - "offset": 1542, + "offset": 1617, "selector": "0x127a04cfe41aceb22fc022bce0c5c70f2d860a7c7c054681bd821cdc18e6dbc" }, { - "offset": 1902, + "offset": 1977, "selector": "0x12ead94ae9d3f9d2bdb6b847cf255f1f398193a1f88884a0ae8e18f24a037b6" }, { @@ -712,23 +760,23 @@ "selector": "0x137a07fa9c479e27114b8ae1fbf252f2065cf91a0d8615272e060a7ccf37309" }, { - "offset": 1955, + "offset": 2030, "selector": "0x14dae1999ae9ab799bc72def6dc6e90890cf8ac0d64525021b7e71d05cb13e8" }, { - "offset": 1433, + "offset": 1508, "selector": "0x167ac610845cc0ab1501b38169a7e50f1bf60602d3c2a961b30987454f97812" }, { - "offset": 964, + "offset": 1039, "selector": "0x169f135eddda5ab51886052d777a57f2ea9c162d713691b5e04a6d4ed71d47f" }, { - "offset": 1866, + "offset": 1941, "selector": "0x1ae1a515cf2d214b29bdf63a79ee2d490efd4dd1acc99d383a8e549c3cecb5d" }, { - "offset": 1086, + "offset": 1161, "selector": "0x1b1a0649752af1b28b3dc29a1556eee781e4a4c3a1f7f53f90fa834de098c4d" }, { @@ -736,7 +784,7 @@ "selector": "0x1b47f727a0668d8593c5bb115d5b53a470f29833fd4d598e748f68e65f4f003" }, { - "offset": 1512, + "offset": 1587, "selector": "0x1de4779362d5ca708d55fe1d4d499501b7f692730d2e01656e9180708985e07" }, { @@ -744,19 +792,23 @@ "selector": "0x27c3334165536f239cfd400ed956eabff55fc60de4fb56728b6a4f6b87db01c" }, { - "offset": 1378, + "offset": 929, + "selector": "0x298e03955860424b6a946506da72353a645f653dc1879f6b55fd756f3d20a59" + }, + { + "offset": 1453, "selector": "0x309687d54611a7db521175c78ba48b082df1372350d2529981a8c0dd09a6529" }, { - "offset": 1781, + "offset": 1856, "selector": "0x30f842021fbf02caf80d09a113997c1e00a32870eee0c6136bed27acb348bea" }, { - "offset": 1701, + "offset": 1776, "selector": "0x317eb442b72a9fae758d4fb26830ed0d9f31c8e7da4dbff4e8c59ea6a158e7f" }, { - "offset": 1218, + "offset": 1293, "selector": "0x32564d7e0fe091d49b4c20f4632191e4ed6986bf993849879abfef9465def25" }, { @@ -764,7 +816,7 @@ "selector": "0x3307b3297ab2ab7a46a9b7d139a52dddf9c343e9a0a3ac69c5b4048d80e3aaf" }, { - "offset": 1457, + "offset": 1532, "selector": "0x33ce93a3eececa5c9fc70da05f4aff3b00e1820b79587924d514bc76788991a" }, { @@ -772,11 +824,11 @@ "selector": "0x3604cea1cdb094a73a31144f14a3e5861613c008e1e879939ebc4827d10cd50" }, { - "offset": 1016, + "offset": 1091, "selector": "0x36fa6de2810d05c3e1a0ebe23f60b9c2f4629bbead09e5a9704e1c5632630d5" }, { - "offset": 1052, + "offset": 1127, "selector": "0x38215592552d97419658d30db8f189b242ec2056641de3dff8a7217745ec205" }, { @@ -796,15 +848,15 @@ "selector": "0x3b097c62d3e4b85742aadd0dfb823f96134b886ec13bda57b68faf86f294d97" }, { - "offset": 904, + "offset": 979, "selector": "0x3bf01fb7497d041938cb7b2954d8c4590006d26b3acd0f5aec1af45dc4f94b2" }, { - "offset": 1409, + "offset": 1484, "selector": "0x3dc5da2d6d1275aeed57f43461d31967b0fed58bfe739b4ffad4091e89c4b03" }, { - "offset": 1244, + "offset": 1319, "selector": "0x3eb640b15f75fcc06d43182cdb94ed38c8e71755d5fb57c16dd673b466db1d4" } ], @@ -818,16 +870,16 @@ "__main__", "__main__.test_call_contract_fail_with_attr_error_msg" ], - "end_pc": 902, + "end_pc": 977, "flow_tracking_data": { "ap_tracking": { - "group": 75, + "group": 80, "offset": 0 }, "reference_ids": {} }, "name": "error_message", - "start_pc": 892, + "start_pc": 967, "value": "Be aware of failure ahead..." }, { @@ -836,16 +888,16 @@ "__main__", "__main__.fail" ], - "end_pc": 1217, + "end_pc": 1292, "flow_tracking_data": { "ap_tracking": { - "group": 97, + "group": 102, "offset": 0 }, "reference_ids": {} }, "name": "error_message", - "start_pc": 1213, + "start_pc": 1288, "value": "You shall not pass!" } ], @@ -1749,8 +1801,83 @@ "0x48127ff87fff8000", "0x48127ff87fff8000", "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x5", + "0x480a7ff57fff8000", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc9c", + "0x40137ffe7fff8000", + "0x48127ffd7fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc94", + "0x40137fff7fff8001", + "0x40137ffe7fff8002", + "0x40137ffd7fff8003", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc71", + "0x40137fff7fff8004", + "0x480a80047fff8000", + "0x48127ff07fff8000", + "0x480a80007fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc74", + "0x482a800080048000", + "0x480a80017fff8000", + "0x480a80027fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc6f", + "0x480a80037fff8000", + "0x482a800280008000", + "0x480a80047fff8000", + "0x208b7fff7fff7ffe", + "0x480280027ffb8000", + "0x480280027ffd8000", + "0x400080007ffe7fff", + "0x482680017ffd8000", + "0x3", + "0x480280027ffd8000", + "0x48307fff7ffe8000", + "0x480280027ffb8000", + "0x480080027ffe8000", + "0x400080017ffe7fff", + "0x482480017ffd8000", + "0x3", + "0x480080027ffc8000", + "0x48307fff7ffe8000", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x480280027ffd8000", + "0x482680017ffd8000", + "0x3", + "0x480080007ff58000", + "0x480080017ff48000", + "0x480080027ff38000", + "0x482480017ff28000", + "0x3", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc2", + "0x480280027ffb8000", + "0x48127ffc7fff8000", + "0x480280017ffb8000", + "0x482480017ffd8000", + "0x2", + "0x480280037ffb8000", + "0x480280047ffb8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc9e", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc53", "0x480a7ffb7fff8000", "0x480a7ffc7fff8000", "0x480a7ffd7fff8000", @@ -1758,7 +1885,7 @@ "0x0", "0x48127ffb7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc9b", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc50", "0x48127ffd7fff8000", "0x208b7fff7fff7ffe", "0x482680017ffd8000", @@ -1783,7 +1910,7 @@ "0x480a7ffc7fff8000", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffceb", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffca0", "0x208b7fff7fff7ffe", "0x482680017ffd8000", "0x1", @@ -1810,7 +1937,7 @@ "0x480a7ffc7fff8000", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc7f", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc34", "0x208b7fff7fff7ffe", "0x40780017fff7fff", "0x1", @@ -1862,11 +1989,11 @@ "0x480680017fff8000", "0x27", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffddc", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd91", "0x480680017fff8000", "0x1", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffdca", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd7f", "0x400680017fff7fff", "0x27", "0x48127ffc7fff8000", @@ -1898,7 +2025,7 @@ "0x480a7ffc7fff8000", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd7d", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd32", "0x208b7fff7fff7ffe", "0x40780017fff7fff", "0x1", @@ -1982,7 +2109,7 @@ "0x482680017ffd8000", "0x3", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffbbb", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffb70", "0x48127ffd7fff8000", "0x480680017fff8000", "0x0", @@ -2000,7 +2127,7 @@ "0x482680017ffd8000", "0x3", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffbb5", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffb6a", "0x48127ffd7fff8000", "0x480680017fff8000", "0x0", @@ -2154,7 +2281,7 @@ "0x482680017ffd8000", "0x800000000000011000000000000000000000000000000000000000000000000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffb0a", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffabf", "0x482480017fff8000", "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffe", "0x40137fff7fff8000", @@ -2165,7 +2292,7 @@ "0x3", "0x480a80007fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffb04", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffab9", "0x48127ffd7fff8000", "0x208b7fff7fff7ffe", "0x482680017ffd8000", @@ -2194,15 +2321,15 @@ "0x480a7ff97fff8000", "0x480a7ffa7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffb37", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffaec", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffb09", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffabe", "0x480a7ffb7fff8000", "0x480a7ffc7fff8000", "0x480680017fff8000", "0x0", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffada", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa8f", "0x482480017fff8000", "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffd", "0x40137fff7fff8000", @@ -2214,7 +2341,7 @@ "0x4", "0x480a80007fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffad3", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa88", "0x208b7fff7fff7ffe", "0x40780017fff7fff", "0x3", @@ -2230,7 +2357,7 @@ "0x480a7ffc7fff8000", "0x480a7ffb7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffaae", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa63", "0x480a80017fff8000", "0x4829800080008002", "0x480a80007fff8000", @@ -2262,7 +2389,7 @@ "0x208b7fff7fff7ffe", "0x480a7ffc7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffad5", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa8a", "0x400a7ffd7fff7fff", "0x48127ffe7fff8000", "0x208b7fff7fff7ffe", @@ -2286,7 +2413,7 @@ "0x208b7fff7fff7ffe", "0x480a7ffc7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffac4", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa79", "0x400a7ffd7fff7fff", "0x48127ffe7fff8000", "0x208b7fff7fff7ffe", @@ -2310,7 +2437,7 @@ "0x208b7fff7fff7ffe", "0x480a7ffc7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa9e", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa53", "0x400a7ffd7fff7fff", "0x48127ffe7fff8000", "0x208b7fff7fff7ffe", @@ -2334,7 +2461,7 @@ "0x208b7fff7fff7ffe", "0x480a7ff67fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffabd", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa72", "0x480080007fff8000", "0x480080017ffe8000", "0x480080027ffd8000", @@ -2356,17 +2483,17 @@ "0x12c", "0x48127ffb7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa95", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa4a", "0x480680017fff8000", "0x137", "0x48127ff67fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa90", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa45", "0x480680017fff8000", "0x142", "0x48127ff17fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa8b", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa40", "0x480a7ff77fff8000", "0x208b7fff7fff7ffe", "0x482680017ffd8000", @@ -2395,7 +2522,7 @@ "0x208b7fff7fff7ffe", "0x480a7ffc7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa80", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa35", "0x400180007fff7ffd", "0x48127ffe7fff8000", "0x208b7fff7fff7ffe", @@ -2423,13 +2550,13 @@ "0x480680017fff8000", "0x0", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa52", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa07", "0x480680017fff8000", "0xf", "0x480680017fff8000", "0x1", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa4c", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa01", "0x480a7ffd7fff8000", "0x208b7fff7fff7ffe", "0x402b7ffd7ffc7ffd", @@ -2451,7 +2578,7 @@ "0x40780017fff7fff", "0x1", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9c8", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff97d", "0x40137fff7fff8000", "0x4003800080007ffb", "0x4003800180007ffc", @@ -2465,7 +2592,7 @@ "0x4828800080007ffc", "0x480a80007fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9d8", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff98d", "0x48127ffd7fff8000", "0x480a7ff97fff8000", "0x208b7fff7fff7ffe", @@ -2474,11 +2601,11 @@ "0x2691cb735b18f3f656c3b82bd97a32b65d15019b64117513f8604d1e06fe58b", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9b4", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff969", "0x480a7ffc7fff8000", "0x48127ffe7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa48", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9fd", "0x48127fe17fff8000", "0x48127ffd7fff8000", "0x48127ffd7fff8000", @@ -2491,12 +2618,12 @@ "0x480a7ffa7fff8000", "0x48127ffe7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa06", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9bb", "0x48127ffe7fff8000", "0x482480017ff78000", "0x1", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa01", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9b6", "0x48127ffe7fff8000", "0x48127fee7fff8000", "0x48127fee7fff8000", @@ -2512,12 +2639,12 @@ "0x48127ffe7fff8000", "0x480a7ffc7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9f9", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9ae", "0x482480017ff88000", "0x1", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9f4", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9a9", "0x48127ff07fff8000", "0x48127ff07fff8000", "0x208b7fff7fff7ffe", @@ -2534,12 +2661,12 @@ "0x48127ffe7fff8000", "0x480a7ffc7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9e3", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff998", "0x482480017ff88000", "0x1", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9de", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff993", "0x48127ff07fff8000", "0x48127ff07fff8000", "0x208b7fff7fff7ffe", @@ -2590,12 +2717,12 @@ "0x48127ffd7fff8000", "0x480a7ffc7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa00", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9b5", "0x48127ffe7fff8000", "0x48127ff77fff8000", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9fb", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9b0", "0x48127fed7fff8000", "0x48127fed7fff8000", "0x48127fed7fff8000", @@ -2672,7 +2799,7 @@ "0x480680017fff8000", "0x4b5810004d9272776dec83ecc20c19353453b956e594188890b48467cb53c19", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9f0", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9a5", "0x480a7ffa7fff8000", "0x480a7ffb7fff8000", "0x480a7ffc7fff8000", @@ -2702,7 +2829,7 @@ "0x208b7fff7fff7ffe", "0x480a7ffc7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff92b", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff8e0", "0x400680017fff7ffe", "0x2", "0x48127ffd7fff8000", @@ -2750,14 +2877,14 @@ "0x400780017fff8001", "0x22", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff8b5", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff86a", "0x480a7ffc7fff8000", "0x480a7ffd7fff8000", "0x480680017fff8000", "0x2", "0x48127ffb7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9ba", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff96f", "0x208b7fff7fff7ffe", "0x482680017ffd8000", "0x1", @@ -2789,7 +2916,7 @@ "0x480a7ffc7fff8000", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff8ec", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff8a1", "0x480a7ff77fff8000", "0x480a7ff87fff8000", "0x482680017ff98000", @@ -3472,7 +3599,7 @@ } } ], - "912": [ + "987": [ { "accessible_scopes": [ "__main__", @@ -3483,14 +3610,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 76, + "group": 81, "offset": 23 }, "reference_ids": {} } } ], - "935": [ + "1010": [ { "accessible_scopes": [ "__main__", @@ -3501,14 +3628,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 78, + "group": 83, "offset": 11 }, "reference_ids": {} } } ], - "955": [ + "1030": [ { "accessible_scopes": [ "__main__", @@ -3519,14 +3646,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 80, + "group": 85, "offset": 0 }, "reference_ids": {} } } ], - "1022": [ + "1097": [ { "accessible_scopes": [ "__main__", @@ -3537,14 +3664,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 83, + "group": 88, "offset": 126 }, "reference_ids": {} } } ], - "1043": [ + "1118": [ { "accessible_scopes": [ "__main__", @@ -3555,14 +3682,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 86, + "group": 91, "offset": 0 }, "reference_ids": {} } } ], - "1089": [ + "1164": [ { "accessible_scopes": [ "__main__", @@ -3573,14 +3700,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 90, + "group": 95, "offset": 2 }, "reference_ids": {} } } ], - "1176": [ + "1251": [ { "accessible_scopes": [ "__main__", @@ -3591,14 +3718,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 94, + "group": 99, "offset": 0 }, "reference_ids": {} } } ], - "1221": [ + "1296": [ { "accessible_scopes": [ "__main__", @@ -3609,14 +3736,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 98, + "group": 103, "offset": 3 }, "reference_ids": {} } } ], - "1250": [ + "1325": [ { "accessible_scopes": [ "__main__", @@ -3627,14 +3754,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 102, + "group": 107, "offset": 0 }, "reference_ids": {} } } ], - "1275": [ + "1350": [ { "accessible_scopes": [ "__main__", @@ -3645,14 +3772,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 106, + "group": 111, "offset": 0 }, "reference_ids": {} } } ], - "1320": [ + "1395": [ { "accessible_scopes": [ "__main__", @@ -3663,14 +3790,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 109, + "group": 114, "offset": 0 }, "reference_ids": {} } } ], - "1359": [ + "1434": [ { "accessible_scopes": [ "__main__", @@ -3681,14 +3808,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 111, + "group": 116, "offset": 0 }, "reference_ids": {} } } ], - "1416": [ + "1491": [ { "accessible_scopes": [ "__main__", @@ -3699,14 +3826,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 116, + "group": 121, "offset": 12 }, "reference_ids": {} } } ], - "1440": [ + "1515": [ { "accessible_scopes": [ "__main__", @@ -3717,14 +3844,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 118, + "group": 123, "offset": 12 }, "reference_ids": {} } } ], - "1464": [ + "1539": [ { "accessible_scopes": [ "__main__", @@ -3735,14 +3862,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 120, + "group": 125, "offset": 12 }, "reference_ids": {} } } ], - "1525": [ + "1600": [ { "accessible_scopes": [ "__main__", @@ -3753,14 +3880,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 122, + "group": 127, "offset": 45 }, "reference_ids": {} } } ], - "1549": [ + "1624": [ { "accessible_scopes": [ "__main__", @@ -3771,14 +3898,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 124, + "group": 129, "offset": 12 }, "reference_ids": {} } } ], - "1580": [ + "1655": [ { "accessible_scopes": [ "__main__", @@ -3789,14 +3916,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 126, + "group": 131, "offset": 18 }, "reference_ids": {} } } ], - "1712": [ + "1787": [ { "accessible_scopes": [ "__main__", @@ -3807,14 +3934,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 134, + "group": 139, "offset": 145 }, "reference_ids": {} } } ], - "1761": [ + "1836": [ { "accessible_scopes": [ "__main__", @@ -3825,14 +3952,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 136, + "group": 141, "offset": 161 }, "reference_ids": {} } } ], - "1792": [ + "1867": [ { "accessible_scopes": [ "__main__", @@ -3843,14 +3970,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 138, + "group": 143, "offset": 35 }, "reference_ids": {} } } ], - "1832": [ + "1907": [ { "accessible_scopes": [ "__main__", @@ -3861,14 +3988,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 142, + "group": 147, "offset": 0 }, "reference_ids": {} } } ], - "1875": [ + "1950": [ { "accessible_scopes": [ "__main__", @@ -3879,14 +4006,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 144, + "group": 149, "offset": 153 }, "reference_ids": {} } } ], - "1909": [ + "1984": [ { "accessible_scopes": [ "__main__", @@ -3897,14 +4024,14 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 146, + "group": 151, "offset": 17 }, "reference_ids": {} } } ], - "1984": [ + "2059": [ { "accessible_scopes": [ "__main__", @@ -3915,7 +4042,7 @@ "code": "memory[ap] = segments.add()", "flow_tracking_data": { "ap_tracking": { - "group": 152, + "group": 157, "offset": 0 }, "reference_ids": {} @@ -4004,7 +4131,7 @@ }, "__main__.MyContract.xor_counters": { "decorators": [], - "pc": 1591, + "pc": 1666, "type": "function" }, "__main__.MyContract.xor_counters.Args": { @@ -4057,7 +4184,7 @@ "decorators": [ "external" ], - "pc": 1843, + "pc": 1918, "type": "function" }, "__main__.add_signature_to_counters.Args": { @@ -4102,7 +4229,7 @@ "decorators": [ "external" ], - "pc": 1686, + "pc": 1761, "type": "function" }, "__main__.advance_counter.Args": { @@ -4151,6 +4278,10 @@ "type": "const", "value": 0 }, + "__main__.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, "__main__.bitwise_and": { "decorators": [ "external" @@ -4204,7 +4335,7 @@ "decorators": [ "external" ], - "pc": 1772, + "pc": 1847, "type": "function" }, "__main__.call_xor_counters.Args": { @@ -4323,7 +4454,7 @@ }, "__main__.ec_point.addr": { "decorators": [], - "pc": 1664, + "pc": 1739, "type": "function" }, "__main__.ec_point.addr.Args": { @@ -4373,7 +4504,7 @@ }, "__main__.ec_point.write": { "decorators": [], - "pc": 1669, + "pc": 1744, "type": "function" }, "__main__.ec_point.write.Args": { @@ -4420,7 +4551,7 @@ }, "__main__.emit_event_recurse": { "decorators": [], - "pc": 1920, + "pc": 1995, "type": "function" }, "__main__.emit_event_recurse.Args": { @@ -4481,7 +4612,7 @@ "decorators": [ "external" ], - "pc": 1213, + "pc": 1288, "type": "function" }, "__main__.fail.Args": { @@ -4508,7 +4639,7 @@ "decorators": [ "external" ], - "pc": 1085, + "pc": 1160, "type": "function" }, "__main__.foo.Args": { @@ -4567,7 +4698,7 @@ "decorators": [ "external" ], - "pc": 1100, + "pc": 1175, "type": "function" }, "__main__.invoke_call_chain.Args": { @@ -4608,6 +4739,10 @@ "destination": "starkware.starknet.common.syscalls.library_call", "type": "alias" }, + "__main__.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, "__main__.number_map": { "type": "namespace" }, @@ -4784,7 +4919,7 @@ "decorators": [ "external" ], - "pc": 1261, + "pc": 1336, "type": "function" }, "__main__.recurse.Args": { @@ -4816,7 +4951,7 @@ "decorators": [ "external" ], - "pc": 1232, + "pc": 1307, "type": "function" }, "__main__.recursive_fail.Args": { @@ -4848,7 +4983,7 @@ "decorators": [ "external" ], - "pc": 1286, + "pc": 1361, "type": "function" }, "__main__.recursive_syscall.Args": { @@ -4929,7 +5064,7 @@ "decorators": [ "external" ], - "pc": 1886, + "pc": 1961, "type": "function" }, "__main__.send_message.Args": { @@ -5095,7 +5230,7 @@ "decorators": [ "external" ], - "pc": 892, + "pc": 967, "type": "function" }, "__main__.test_call_contract_fail_with_attr_error_msg.Args": { @@ -5132,11 +5267,77 @@ "type": "const", "value": 0 }, + "__main__.test_call_two_contracts": { + "decorators": [ + "external", + "raw_output" + ], + "pc": 892, + "type": "function" + }, + "__main__.test_call_two_contracts.Args": { + "full_name": "__main__.test_call_two_contracts.Args", + "members": { + "calldata_0": { + "cairo_type": "felt*", + "offset": 3 + }, + "calldata_0_len": { + "cairo_type": "felt", + "offset": 2 + }, + "calldata_1": { + "cairo_type": "felt*", + "offset": 7 + }, + "calldata_1_len": { + "cairo_type": "felt", + "offset": 6 + }, + "contract_address_0": { + "cairo_type": "felt", + "offset": 0 + }, + "contract_address_1": { + "cairo_type": "felt", + "offset": 4 + }, + "function_selector_0": { + "cairo_type": "felt", + "offset": 1 + }, + "function_selector_1": { + "cairo_type": "felt", + "offset": 5 + } + }, + "size": 8, + "type": "struct" + }, + "__main__.test_call_two_contracts.ImplicitArgs": { + "full_name": "__main__.test_call_two_contracts.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.test_call_two_contracts.Return": { + "cairo_type": "(retdata_size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__main__.test_call_two_contracts.SIZEOF_LOCALS": { + "type": "const", + "value": 5 + }, "__main__.test_contract_address": { "decorators": [ "external" ], - "pc": 1033, + "pc": 1108, "type": "function" }, "__main__.test_contract_address.Args": { @@ -5193,7 +5394,7 @@ "decorators": [ "external" ], - "pc": 1560, + "pc": 1635, "type": "function" }, "__main__.test_count_actual_storage_changes.Args": { @@ -5233,7 +5434,7 @@ "decorators": [ "external" ], - "pc": 946, + "pc": 1021, "type": "function" }, "__main__.test_deploy.Args": { @@ -5286,7 +5487,7 @@ "decorators": [ "external" ], - "pc": 1803, + "pc": 1878, "type": "function" }, "__main__.test_ec_op.Args": { @@ -5330,7 +5531,7 @@ "decorators": [ "external" ], - "pc": 1944, + "pc": 2019, "type": "function" }, "__main__.test_emit_events.Args": { @@ -5391,7 +5592,7 @@ "decorators": [ "external" ], - "pc": 1403, + "pc": 1478, "type": "function" }, "__main__.test_get_block_number.Args": { @@ -5428,7 +5629,7 @@ "decorators": [ "external" ], - "pc": 1427, + "pc": 1502, "type": "function" }, "__main__.test_get_block_timestamp.Args": { @@ -5465,7 +5666,7 @@ "decorators": [ "external" ], - "pc": 1451, + "pc": 1526, "type": "function" }, "__main__.test_get_sequencer_address.Args": { @@ -5502,7 +5703,7 @@ "decorators": [ "external" ], - "pc": 1475, + "pc": 1550, "type": "function" }, "__main__.test_get_tx_info.Args": { @@ -5693,7 +5894,7 @@ "decorators": [ "external" ], - "pc": 923, + "pc": 998, "type": "function" }, "__main__.test_replace_class.Args": { @@ -5771,7 +5972,7 @@ "decorators": [ "external" ], - "pc": 997, + "pc": 1072, "type": "function" }, "__main__.test_storage_var.Args": { @@ -5811,7 +6012,7 @@ "decorators": [ "external" ], - "pc": 1536, + "pc": 1611, "type": "function" }, "__main__.test_tx_version.Args": { @@ -5848,7 +6049,7 @@ "decorators": [ "external" ], - "pc": 1331, + "pc": 1406, "type": "function" }, "__main__.test_write_and_transfer.Args": { @@ -5926,7 +6127,7 @@ }, "__main__.two_counters.addr": { "decorators": [], - "pc": 1612, + "pc": 1687, "type": "function" }, "__main__.two_counters.addr.Args": { @@ -5973,7 +6174,7 @@ }, "__main__.two_counters.read": { "decorators": [], - "pc": 1626, + "pc": 1701, "type": "function" }, "__main__.two_counters.read.Args": { @@ -6024,7 +6225,7 @@ }, "__main__.two_counters.write": { "decorators": [], - "pc": 1646, + "pc": 1721, "type": "function" }, "__main__.two_counters.write.Args": { @@ -6214,7 +6415,7 @@ "decorators": [ "external" ], - "pc": 1723, + "pc": 1798, "type": "function" }, "__main__.xor_counters.Args": { @@ -6263,7 +6464,7 @@ "decorators": [ "external" ], - "pc": 1866, + "pc": 1941, "type": "function" }, "__wrappers__.add_signature_to_counters.Args": { @@ -6298,7 +6499,7 @@ "decorators": [ "external" ], - "pc": 1701, + "pc": 1776, "type": "function" }, "__wrappers__.advance_counter.Args": { @@ -6368,7 +6569,7 @@ "decorators": [ "external" ], - "pc": 1781, + "pc": 1856, "type": "function" }, "__wrappers__.call_xor_counters.Args": { @@ -6438,7 +6639,7 @@ "decorators": [ "external" ], - "pc": 1218, + "pc": 1293, "type": "function" }, "__wrappers__.fail.Args": { @@ -6473,7 +6674,7 @@ "decorators": [ "external" ], - "pc": 1086, + "pc": 1161, "type": "function" }, "__wrappers__.foo.Args": { @@ -6508,7 +6709,7 @@ "decorators": [ "external" ], - "pc": 1185, + "pc": 1260, "type": "function" }, "__wrappers__.invoke_call_chain.Args": { @@ -6537,7 +6738,7 @@ }, "__wrappers__.invoke_call_chain_encode_return": { "decorators": [], - "pc": 1176, + "pc": 1251, "type": "function" }, "__wrappers__.invoke_call_chain_encode_return.Args": { @@ -6577,7 +6778,7 @@ "decorators": [ "external" ], - "pc": 1269, + "pc": 1344, "type": "function" }, "__wrappers__.recurse.Args": { @@ -6612,7 +6813,7 @@ "decorators": [ "external" ], - "pc": 1244, + "pc": 1319, "type": "function" }, "__wrappers__.recursive_fail.Args": { @@ -6647,7 +6848,7 @@ "decorators": [ "external" ], - "pc": 1311, + "pc": 1386, "type": "function" }, "__wrappers__.recursive_syscall.Args": { @@ -6751,7 +6952,7 @@ "decorators": [ "external" ], - "pc": 1902, + "pc": 1977, "type": "function" }, "__wrappers__.send_message.Args": { @@ -6857,7 +7058,7 @@ "decorators": [ "external" ], - "pc": 904, + "pc": 979, "type": "function" }, "__wrappers__.test_call_contract_fail_with_attr_error_msg.Args": { @@ -6888,11 +7089,47 @@ "destination": "starkware.cairo.common.memcpy.memcpy", "type": "alias" }, + "__wrappers__.test_call_two_contracts": { + "decorators": [ + "external", + "raw_output" + ], + "pc": 929, + "type": "function" + }, + "__wrappers__.test_call_two_contracts.Args": { + "full_name": "__wrappers__.test_call_two_contracts.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.test_call_two_contracts.ImplicitArgs": { + "full_name": "__wrappers__.test_call_two_contracts.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.test_call_two_contracts.Return": { + "cairo_type": "(syscall_ptr: felt*, pedersen_ptr: felt, range_check_ptr: felt, bitwise_ptr: felt, ec_op_ptr: felt, size: felt, retdata: felt*)", + "type": "type_definition" + }, + "__wrappers__.test_call_two_contracts.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.test_call_two_contracts.__wrapped_func": { + "destination": "__main__.test_call_two_contracts", + "type": "alias" + }, + "__wrappers__.test_call_two_contracts_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, "__wrappers__.test_contract_address": { "decorators": [ "external" ], - "pc": 1052, + "pc": 1127, "type": "function" }, "__wrappers__.test_contract_address.Args": { @@ -6921,7 +7158,7 @@ }, "__wrappers__.test_contract_address_encode_return": { "decorators": [], - "pc": 1043, + "pc": 1118, "type": "function" }, "__wrappers__.test_contract_address_encode_return.Args": { @@ -6961,7 +7198,7 @@ "decorators": [ "external" ], - "pc": 1575, + "pc": 1650, "type": "function" }, "__wrappers__.test_count_actual_storage_changes.Args": { @@ -6996,7 +7233,7 @@ "decorators": [ "external" ], - "pc": 964, + "pc": 1039, "type": "function" }, "__wrappers__.test_deploy.Args": { @@ -7025,7 +7262,7 @@ }, "__wrappers__.test_deploy_encode_return": { "decorators": [], - "pc": 955, + "pc": 1030, "type": "function" }, "__wrappers__.test_deploy_encode_return.Args": { @@ -7065,7 +7302,7 @@ "decorators": [ "external" ], - "pc": 1825, + "pc": 1900, "type": "function" }, "__wrappers__.test_ec_op.Args": { @@ -7100,7 +7337,7 @@ "decorators": [ "external" ], - "pc": 1955, + "pc": 2030, "type": "function" }, "__wrappers__.test_emit_events.Args": { @@ -7135,7 +7372,7 @@ "decorators": [ "external" ], - "pc": 1409, + "pc": 1484, "type": "function" }, "__wrappers__.test_get_block_number.Args": { @@ -7170,7 +7407,7 @@ "decorators": [ "external" ], - "pc": 1433, + "pc": 1508, "type": "function" }, "__wrappers__.test_get_block_timestamp.Args": { @@ -7205,7 +7442,7 @@ "decorators": [ "external" ], - "pc": 1457, + "pc": 1532, "type": "function" }, "__wrappers__.test_get_sequencer_address.Args": { @@ -7240,7 +7477,7 @@ "decorators": [ "external" ], - "pc": 1512, + "pc": 1587, "type": "function" }, "__wrappers__.test_get_tx_info.Args": { @@ -7449,7 +7686,7 @@ "decorators": [ "external" ], - "pc": 928, + "pc": 1003, "type": "function" }, "__wrappers__.test_replace_class.Args": { @@ -7553,7 +7790,7 @@ "decorators": [ "external" ], - "pc": 1016, + "pc": 1091, "type": "function" }, "__wrappers__.test_storage_var.Args": { @@ -7588,7 +7825,7 @@ "decorators": [ "external" ], - "pc": 1542, + "pc": 1617, "type": "function" }, "__wrappers__.test_tx_version.Args": { @@ -7623,7 +7860,7 @@ "decorators": [ "external" ], - "pc": 1378, + "pc": 1453, "type": "function" }, "__wrappers__.test_write_and_transfer.Args": { @@ -7652,7 +7889,7 @@ }, "__wrappers__.test_write_and_transfer_encode_return": { "decorators": [], - "pc": 1359, + "pc": 1434, "type": "function" }, "__wrappers__.test_write_and_transfer_encode_return.Args": { @@ -7832,7 +8069,7 @@ "decorators": [ "external" ], - "pc": 1749, + "pc": 1824, "type": "function" }, "__wrappers__.xor_counters.Args": { diff --git a/crates/blockifier/feature_contracts/cairo0/test_contract.cairo b/crates/blockifier/feature_contracts/cairo0/test_contract.cairo index 8f2cfc67013..0e15cd56596 100644 --- a/crates/blockifier/feature_contracts/cairo0/test_contract.cairo +++ b/crates/blockifier/feature_contracts/cairo0/test_contract.cairo @@ -1,10 +1,12 @@ %lang starknet +from starkware.cairo.common.alloc import alloc from starkware.cairo.common.bitwise import bitwise_xor from starkware.cairo.common.bool import FALSE from starkware.cairo.common.cairo_builtins import BitwiseBuiltin, HashBuiltin, EcOpBuiltin from starkware.cairo.common.ec import ec_op from starkware.cairo.common.ec_point import EcPoint +from starkware.cairo.common.memcpy import memcpy from starkware.cairo.common.registers import get_fp_and_pc from starkware.starknet.common.messages import send_message_to_l1 from starkware.starknet.common.syscalls import ( @@ -165,6 +167,39 @@ func test_call_contract{syscall_ptr: felt*}( return (retdata_size=retdata_size, retdata=retdata); } +@external +@raw_output +func test_call_two_contracts{syscall_ptr: felt*}( + contract_address_0: felt, + function_selector_0: felt, + calldata_0_len: felt, + calldata_0: felt*, + contract_address_1: felt, + function_selector_1: felt, + calldata_1_len: felt, + calldata_1: felt*, +) -> (retdata_size: felt, retdata: felt*) { + alloc_locals; + + let (retdata_0_len: felt, retdata_0: felt*) = call_contract( + contract_address=contract_address_0, + function_selector=function_selector_0, + calldata_size=calldata_0_len, + calldata=calldata_0, + ); + let (retdata_1_len: felt, retdata_1: felt*) = call_contract( + contract_address=contract_address_1, + function_selector=function_selector_1, + calldata_size=calldata_1_len, + calldata=calldata_1, + ); + + let retdata: felt* = alloc(); + memcpy(dst=retdata, src=retdata_0, len=retdata_0_len); + memcpy(dst=retdata + retdata_0_len, src=retdata_1, len=retdata_1_len); + return (retdata_size=retdata_0_len + retdata_1_len, retdata=retdata); +} + @external func test_call_contract_fail_with_attr_error_msg{syscall_ptr: felt*}( contract_address: felt, function_selector: felt @@ -519,4 +554,3 @@ func test_emit_events{syscall_ptr: felt*, pedersen_ptr: HashBuiltin*, range_chec ) { return emit_event_recurse(events_count, keys_len, keys, data_len, data); } - diff --git a/crates/blockifier/feature_contracts/cairo1/compiled/test_contract.casm.json b/crates/blockifier/feature_contracts/cairo1/compiled/test_contract.casm.json index e83fe5605aa..8ae97e8bc47 100644 --- a/crates/blockifier/feature_contracts/cairo1/compiled/test_contract.casm.json +++ b/crates/blockifier/feature_contracts/cairo1/compiled/test_contract.casm.json @@ -100,9 +100,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x4a6e", + "0x4d24", "0x482480017fff8000", - "0x4a6d", + "0x4d23", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -275,9 +275,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x49bf", + "0x4c75", "0x482480017fff8000", - "0x49be", + "0x4c74", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -536,7 +536,7 @@ "0x48127ffa7fff8000", "0x480080007ff88000", "0x1104800180018000", - "0x1810", + "0x1a42", "0x20680017fff7ffa", "0xb", "0x48127ff87fff8000", @@ -588,9 +588,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x4886", + "0x4b3c", "0x482480017fff8000", - "0x4885", + "0x4b3b", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -715,16 +715,16 @@ "0x1", "0x208b7fff7fff7ffe", "0x40780017fff7fff", - "0x2", + "0x9", "0xa0680017fff8000", "0x7", "0x482680017ffa8000", - "0x100000000000000000000000000000000", + "0xffffffffffffffffffffffffffffe35e", "0x400280007ff97fff", "0x10780017fff7fff", - "0x10c", + "0x21c", "0x4825800180007ffa", - "0x0", + "0x1ca2", "0x400280007ff97fff", "0x482680017ff98000", "0x1", @@ -748,11 +748,11 @@ "0x480680017fff8000", "0x0", "0x20680017fff7ffe", - "0xe1", - "0x40137fff7fff8001", + "0x1f1", + "0x40137fff7fff8008", "0xa0680017fff8004", "0xe", - "0x4825800180048001", + "0x4825800180048008", "0x800000000000000000000000000000000000000000000000000000000000000", "0x484480017ffe8000", "0x110000000000000000", @@ -763,10 +763,10 @@ "0xffffffffffffffeeffffffffffffffff", "0x400080027ff47ffd", "0x10780017fff7fff", - "0xce", + "0x1de", "0x484480017fff8001", "0x8000000000000000000000000000000", - "0x48317fff80008001", + "0x48317fff80008008", "0x480080007ff77ffd", "0x480080017ff67ffd", "0x402480017ffc7ffe", @@ -794,8 +794,8 @@ "0x480680017fff8000", "0x0", "0x20680017fff7ffe", - "0xa1", - "0x40137fff7fff8000", + "0x1b1", + "0x40137fff7fff8003", "0x48307ffc80007ffd", "0x20680017fff7fff", "0x4", @@ -827,7 +827,7 @@ "0x48127ffa7fff8000", "0x480080007ff88000", "0x1104800180018000", - "0x16ed", + "0x191f", "0x20680017fff7ffa", "0xb", "0x48127ff87fff8000", @@ -858,7 +858,140 @@ "0x480680017fff8000", "0x0", "0x20680017fff7ffd", - "0x53", + "0x163", + "0x40137ffe7fff8005", + "0x40137fff7fff8006", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffa8000", + "0x1", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff78000", + "0x10780017fff7fff", + "0x8", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x13b", + "0x40137fff7fff8007", + "0xa0680017fff8004", + "0xe", + "0x4825800180048007", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff07ffc", + "0x480080017fef7ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027fee7ffd", + "0x10780017fff7fff", + "0x128", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48317fff80008007", + "0x480080007ff17ffd", + "0x480080017ff07ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027fef7ffe", + "0x482480017fef8000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xfb", + "0x40137fff7fff8004", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff47fff8000", + "0x48127fe37fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x189a", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff57fff8000", + "0x48127fe47fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0xad", "0x48307ffb80007ffc", "0x20680017fff7fff", "0x4", @@ -879,47 +1012,137 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x4763", + "0x4994", "0x482480017fff8000", - "0x4762", + "0x4993", "0x480080007fff8000", "0xa0680017fff8000", "0x9", "0x4824800180007ff4", - "0x602c", + "0x70d0", "0x482480017fff8000", "0x100000000000000000000000000000000", "0x400080007ff17fff", "0x10780017fff7fff", - "0x23", + "0x7d", "0x4824800180007ff4", - "0x602c", + "0x70d0", "0x400080007ff27fff", "0x482480017ff28000", "0x1", - "0x48127ffe7fff8000", - "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x400280007ffb7fff", + "0x400280017ffb7ffd", + "0x400380027ffb8008", + "0x400380037ffb8003", + "0x400380047ffb8005", + "0x400380057ffb8006", + "0x480280077ffb8000", + "0x20680017fff7fff", + "0x5f", + "0x480280067ffb8000", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x4002800a7ffb7fff", + "0x4002800b7ffb7ffc", + "0x4003800c7ffb8007", + "0x4003800d7ffb8004", + "0x4002800e7ffb7ff0", + "0x4002800f7ffb7ff1", + "0x480280117ffb8000", + "0x20680017fff7fff", + "0x49", + "0x40780017fff7fff", + "0x1", + "0x48127ff77fff8000", + "0x480280107ffb8000", + "0x48127ffd7fff8000", + "0x48127ffc7fff8000", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x402780017ffb8000", + "0x14", + "0x400380127ffb8001", + "0x400380137ffb8002", + "0x1104800180018000", + "0x188a", + "0x20680017fff7ffd", + "0x32", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", "0x480a80017fff8000", - "0x480a80007fff8000", - "0x48127ff27fff8000", - "0x48127ff27fff8000", + "0x480a80027fff8000", "0x1104800180018000", - "0x16fc", + "0x1880", "0x20680017fff7ffd", - "0xc", + "0x21", "0x40780017fff7fff", "0x1", + "0x48307ffd80007ffe", + "0x400080007ffe7fff", "0x48127ff97fff8000", "0x48127ff97fff8000", - "0x48127ff97fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x1104800180018000", + "0x18b3", + "0x20680017fff7ffd", + "0xa", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a80007fff8000", "0x480680017fff8000", "0x0", - "0x48127ffb7fff8000", "0x48127ffa7fff8000", - "0x208b7fff7fff7ffe", "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a80007fff8000", + "0x480680017fff8000", + "0x1", "0x48127ffa7fff8000", "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a80007fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x10780017fff7fff", + "0x17", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a80007fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x10780017fff7fff", + "0x10", + "0x48127ff87fff8000", + "0x480280107ffb8000", + "0x482680017ffb8000", + "0x14", + "0x480280127ffb8000", + "0x480280137ffb8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", "0x480680017fff8000", "0x1", "0x48127ffa7fff8000", @@ -943,6 +1166,55 @@ "0x40780017fff7fff", "0x1", "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202336", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202335", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127fe77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017fee8000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127fee7fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202334", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", "0x4661696c656420746f20646573657269616c697a6520706172616d202333", "0x400080007ffe7fff", "0x48127ff77fff8000", @@ -1081,9 +1353,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x4699", + "0x483f", "0x482480017fff8000", - "0x4698", + "0x483e", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -1103,7 +1375,7 @@ "0x480a7ffb7fff8000", "0x48127fef7fff8000", "0x1104800180018000", - "0x16c3", + "0x17db", "0x20680017fff7ffd", "0xc", "0x40780017fff7fff", @@ -1266,7 +1538,7 @@ "0x48127ffa7fff8000", "0x480080007ff88000", "0x1104800180018000", - "0x1536", + "0x1658", "0x20680017fff7ffa", "0xb", "0x48127ff87fff8000", @@ -1331,7 +1603,7 @@ "0x48127ffa7fff8000", "0x480080007ff88000", "0x1104800180018000", - "0x14f5", + "0x1617", "0x20680017fff7ffa", "0xb", "0x48127ff87fff8000", @@ -1383,9 +1655,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x456b", + "0x4711", "0x482480017fff8000", - "0x456a", + "0x4710", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -1411,7 +1683,7 @@ "0x480a80017fff8000", "0x480a80027fff8000", "0x1104800180018000", - "0x160d", + "0x1725", "0x20680017fff7ffd", "0xc", "0x40780017fff7fff", @@ -1589,9 +1861,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x449d", + "0x4643", "0x482480017fff8000", - "0x449c", + "0x4642", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -1706,7 +1978,7 @@ "0x480a7ffc7fff8000", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x1550", + "0x1668", "0x20680017fff7ffc", "0xf2", "0x48127ff97fff8000", @@ -1717,7 +1989,7 @@ "0x40137ffa7fff8001", "0x40137ffb7fff8002", "0x1104800180018000", - "0x1612", + "0x172a", "0x20680017fff7feb", "0xdf", "0x20680017fff7fee", @@ -1805,9 +2077,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x43c5", + "0x456b", "0x482480017fff8000", - "0x43c4", + "0x456a", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -1849,7 +2121,7 @@ "0x48127fdb7fff8000", "0x48127fdf7fff8000", "0x1104800180018000", - "0x1a43", + "0x1b5b", "0x20680017fff7ffd", "0xc", "0x40780017fff7fff", @@ -2091,7 +2363,7 @@ "0x48127ffa7fff8000", "0x480080007ff88000", "0x1104800180018000", - "0x11fd", + "0x131f", "0x20680017fff7ffa", "0xb", "0x48127ff87fff8000", @@ -2143,9 +2415,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x4273", + "0x4419", "0x482480017fff8000", - "0x4272", + "0x4418", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -2430,9 +2702,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x4154", + "0x42fa", "0x482480017fff8000", - "0x4153", + "0x42f9", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -2454,7 +2726,7 @@ "0x48127fee7fff8000", "0x48127ff27fff8000", "0x1104800180018000", - "0x1956", + "0x1a6e", "0x482480017fc88000", "0x1", "0x48127ffa7fff8000", @@ -2647,9 +2919,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x407b", + "0x4221", "0x482480017fff8000", - "0x407a", + "0x4220", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -2811,7 +3083,7 @@ "0x48127ffa7fff8000", "0x480080007ff88000", "0x1104800180018000", - "0xf2d", + "0x104f", "0x20680017fff7ffa", "0xb", "0x48127ff87fff8000", @@ -2863,9 +3135,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3fa3", + "0x4149", "0x482480017fff8000", - "0x3fa2", + "0x4148", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -3002,9 +3274,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3f18", + "0x40be", "0x482480017fff8000", - "0x3f17", + "0x40bd", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -3036,7 +3308,7 @@ "0x48127ff77fff8000", "0x480080007ffc8000", "0x1104800180018000", - "0x1758", + "0x1870", "0x40780017fff7fff", "0x1", "0x48127ffa7fff8000", @@ -3193,7 +3465,7 @@ "0x48127ffa7fff8000", "0x480080007ff88000", "0x1104800180018000", - "0xdaf", + "0xed1", "0x20680017fff7ffa", "0xb", "0x48127ff87fff8000", @@ -3275,9 +3547,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3e07", + "0x3fad", "0x482480017fff8000", - "0x3e06", + "0x3fac", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -3453,9 +3725,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3d55", + "0x3efb", "0x482480017fff8000", - "0x3d54", + "0x3efa", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -3474,7 +3746,7 @@ "0x48127ffe7fff8000", "0x480a7ffb7fff8000", "0x1104800180018000", - "0x1660", + "0x1778", "0x20680017fff7ffd", "0xc", "0x40780017fff7fff", @@ -3557,9 +3829,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3ced", + "0x3e93", "0x482480017fff8000", - "0x3cec", + "0x3e92", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -3578,7 +3850,7 @@ "0x48127ffe7fff8000", "0x480a7ffb7fff8000", "0x1104800180018000", - "0x16cc", + "0x17e4", "0x20680017fff7ffd", "0xc", "0x40780017fff7fff", @@ -3662,9 +3934,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3c84", + "0x3e2a", "0x482480017fff8000", - "0x3c83", + "0x3e29", "0x480080007fff8000", "0x480080017fff8000", "0x484480017fff8000", @@ -3687,7 +3959,7 @@ "0x480a7ff97fff8000", "0x480a7ffb7fff8000", "0x1104800180018000", - "0x16b2", + "0x17ca", "0x20680017fff7ffd", "0xd", "0x40780017fff7fff", @@ -3774,9 +4046,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3c14", + "0x3dba", "0x482480017fff8000", - "0x3c13", + "0x3db9", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -3795,7 +4067,7 @@ "0x48127ffe7fff8000", "0x480a7ffb7fff8000", "0x1104800180018000", - "0x17a6", + "0x18be", "0x20680017fff7ffd", "0xc", "0x40780017fff7fff", @@ -3920,9 +4192,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3b82", + "0x3d28", "0x482480017fff8000", - "0x3b81", + "0x3d27", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -4070,7 +4342,7 @@ "0x48127ffa7fff8000", "0x480080007ff88000", "0x1104800180018000", - "0xa42", + "0xb64", "0x20680017fff7ffa", "0xb", "0x48127ff87fff8000", @@ -4122,9 +4394,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3ab8", + "0x3c5e", "0x482480017fff8000", - "0x3ab7", + "0x3c5d", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -4145,7 +4417,7 @@ "0x48127ff47fff8000", "0x48127ff47fff8000", "0x1104800180018000", - "0x17d1", + "0x18e9", "0x20680017fff7ffd", "0xe", "0x40780017fff7fff", @@ -4244,9 +4516,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3a3e", + "0x3be4", "0x482480017fff8000", - "0x3a3d", + "0x3be3", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -4358,9 +4630,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x39cc", + "0x3b72", "0x482480017fff8000", - "0x39cb", + "0x3b71", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -4379,7 +4651,7 @@ "0x48127ffe7fff8000", "0x48127ff67fff8000", "0x1104800180018000", - "0x1836", + "0x194e", "0x20680017fff7ffd", "0xc", "0x40780017fff7fff", @@ -4497,9 +4769,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3941", + "0x3ae7", "0x482480017fff8000", - "0x3940", + "0x3ae6", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -4518,7 +4790,7 @@ "0x48127ffe7fff8000", "0x48127ff67fff8000", "0x1104800180018000", - "0x17db", + "0x18f3", "0x20680017fff7ffd", "0xc", "0x40780017fff7fff", @@ -4702,9 +4974,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3874", + "0x3a1a", "0x482480017fff8000", - "0x3873", + "0x3a19", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -4946,9 +5218,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3780", + "0x3926", "0x482480017fff8000", - "0x377f", + "0x3925", "0x480080007fff8000", "0x480080007fff8000", "0x484480017fff8000", @@ -4974,7 +5246,7 @@ "0x48127feb7fff8000", "0x48127fef7fff8000", "0x1104800180018000", - "0x163f", + "0x1757", "0x20680017fff7ffd", "0xd", "0x40780017fff7fff", @@ -5089,7 +5361,7 @@ "0x480a7ffc7fff8000", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x168f", + "0x17a7", "0x20680017fff7ffc", "0x63", "0x48307ffa80007ffb", @@ -5114,9 +5386,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x36d8", + "0x387e", "0x482480017fff8000", - "0x36d7", + "0x387d", "0x480080007fff8000", "0x480080007fff8000", "0x484480017fff8000", @@ -5147,7 +5419,7 @@ "0x48127feb7fff8000", "0x48127feb7fff8000", "0x1104800180018000", - "0x1719", + "0x1831", "0x20680017fff7ffd", "0xe", "0x40780017fff7fff", @@ -5282,7 +5554,7 @@ "0x48127ff67fff8000", "0x48127ff67fff8000", "0x1104800180018000", - "0x15ce", + "0x16e6", "0x20680017fff7ffc", "0x60", "0x48307ffa80007ffb", @@ -5305,9 +5577,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3619", + "0x37bf", "0x482480017fff8000", - "0x3618", + "0x37be", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -5462,9 +5734,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x357c", + "0x3722", "0x482480017fff8000", - "0x357b", + "0x3721", "0x480080007fff8000", "0x480080027fff8000", "0x482480017fff8000", @@ -5485,7 +5757,7 @@ "0x48127ffd7fff8000", "0x480a7ffb7fff8000", "0x1104800180018000", - "0x16e9", + "0x1801", "0x20680017fff7ffd", "0xd", "0x40780017fff7fff", @@ -5594,9 +5866,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x34f8", + "0x369e", "0x482480017fff8000", - "0x34f7", + "0x369d", "0x480080007fff8000", "0x480080007fff8000", "0x484480017fff8000", @@ -5620,7 +5892,7 @@ "0x480a7ffb7fff8000", "0x48127ff17fff8000", "0x1104800180018000", - "0x1784", + "0x189c", "0x20680017fff7ffd", "0xd", "0x40780017fff7fff", @@ -5743,9 +6015,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x3463", + "0x3609", "0x482480017fff8000", - "0x3462", + "0x3608", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -5881,9 +6153,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x33d9", + "0x357f", "0x482480017fff8000", - "0x33d8", + "0x357e", "0x480080007fff8000", "0x480080047fff8000", "0x484480017fff8000", @@ -5911,7 +6183,7 @@ "0x480a7ff77fff8000", "0x48127ffb7fff8000", "0x1104800180018000", - "0x178f", + "0x18a7", "0x20680017fff7ffd", "0xf", "0x40780017fff7fff", @@ -6007,9 +6279,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x335b", + "0x3501", "0x482480017fff8000", - "0x335a", + "0x3500", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -6025,14 +6297,14 @@ "0x400080007ff87fff", "0x480a7ff97fff8000", "0x1104800180018000", - "0x18ef", + "0x1a07", "0x482480017fe88000", "0x1", "0x20680017fff7ffc", "0x17", "0x48127ffb7fff8000", "0x1104800180018000", - "0x18e8", + "0x1a00", "0x20680017fff7ffd", "0xd", "0x40780017fff7fff", @@ -6097,6 +6369,296 @@ "0x482480017ff88000", "0x1", "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x10c", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xe1", + "0x40137fff7fff8001", + "0xa0680017fff8004", + "0xe", + "0x4825800180048001", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0xce", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48317fff80008001", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xa1", + "0x40137fff7fff8000", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff47fff8000", + "0x48127fe77fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x308", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff57fff8000", + "0x48127fe87fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0x53", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3402", + "0x482480017fff8000", + "0x3401", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff4", + "0x602c", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff17fff", + "0x10780017fff7fff", + "0x23", + "0x4824800180007ff4", + "0x602c", + "0x400080007ff27fff", + "0x482480017ff28000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x480a80017fff8000", + "0x480a80007fff8000", + "0x48127ff27fff8000", + "0x48127ff27fff8000", + "0x1104800180018000", + "0x1922", + "0x20680017fff7ffd", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x1", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", "0xa0680017fff8000", "0x7", "0x482680017ffa8000", @@ -6171,9 +6733,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x32b7", + "0x333b", "0x482480017fff8000", - "0x32b6", + "0x333a", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -6377,9 +6939,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x31e9", + "0x326d", "0x482480017fff8000", - "0x31e8", + "0x326c", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -6582,9 +7144,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x311c", + "0x31a0", "0x482480017fff8000", - "0x311b", + "0x319f", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -6787,146 +7349,136 @@ "0x482480017ff78000", "0x1", "0x208b7fff7fff7ffe", - "0x480680017fff8000", - "0x43616c6c436f6e7472616374", - "0x400280007ff97fff", - "0x400380017ff97ff8", - "0x400380027ff97ffa", - "0x400380037ff97ffb", - "0x400380047ff97ffc", - "0x400380057ff97ffd", - "0x480280077ff98000", - "0x20680017fff7fff", - "0x1c", - "0x40780017fff7fff", - "0xc", - "0x40780017fff7fff", - "0x1", - "0x480680017fff8000", - "0x46a6158a16a947e5916b2a2ca68501a45e93d7110e81aa2d6438b1c57c879a3", - "0x400080007ffe7fff", - "0x480680017fff8000", - "0x0", - "0x400080017ffd7fff", - "0x480680017fff8000", - "0x457870656374656420726576657274", - "0x400080027ffc7fff", - "0x480680017fff8000", - "0xf", - "0x400080037ffb7fff", - "0x480a7ff77fff8000", - "0x480280067ff98000", + "0xa0680017fff8000", + "0x7", "0x482680017ff98000", - "0xa", - "0x480680017fff8000", + "0xfffffffffffffffffffffffffffff722", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x2f", + "0x4825800180007ff9", + "0x8de", + "0x400280007ff87fff", + "0x482680017ff88000", "0x1", - "0x48127ff77fff8000", - "0x482480017ff68000", - "0x4", - "0x208b7fff7fff7ffe", - "0x480280087ff98000", - "0x480280097ff98000", - "0x480280067ff98000", - "0x482680017ff98000", - "0xa", - "0x48307ffc80007ffd", + "0x48297ffc80007ffd", "0x20680017fff7fff", "0x4", "0x10780017fff7fff", - "0x51", - "0x4824800180007ffc", + "0xa", + "0x482680017ffc8000", "0x1", - "0x480080007fff8000", - "0x4824800180007fff", - "0x454e545259504f494e545f4641494c4544", - "0x20680017fff7fff", - "0x3a", + "0x480a7ffd7fff8000", "0x480680017fff8000", "0x0", + "0x480a7ffc7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", "0x480680017fff8000", - "0x1275130f95dda36bcbb6e9d28796c1d7e10b6e9fd5ed083e0ede4b12f613528", - "0x480680017fff8000", - "0x53746f7261676552656164", - "0x400080007ff87fff", - "0x400080017ff87ff7", - "0x400080027ff87ffd", - "0x400080037ff87ffe", - "0x480080057ff88000", - "0x20680017fff7fff", - "0x22", - "0x480080067ff78000", - "0x480080047ff68000", - "0x482480017ff58000", - "0x7", - "0x20680017fff7ffd", - "0xe", - "0x40780017fff7fff", - "0x2", - "0x480a7ff77fff8000", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x480680017fff8000", - "0x0", + "0x1", "0x480680017fff8000", "0x0", + "0x20680017fff7ffe", + "0xe", + "0x480080007fff8000", + "0x400280007ffb7fff", + "0x48127ff97fff8000", + "0x48127ff77fff8000", + "0x480a7ffa7fff8000", + "0x482680017ffb8000", + "0x1", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd7", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", "0x480680017fff8000", "0x0", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", "0x208b7fff7fff7ffe", "0x40780017fff7fff", "0x1", "0x480680017fff8000", - "0x76616c7565732073686f756c64206e6f74206368616e67652e", + "0x4f7574206f6620676173", "0x400080007ffe7fff", - "0x480a7ff77fff8000", - "0x48127ffb7fff8000", - "0x48127ffb7fff8000", - "0x480680017fff8000", - "0x1", - "0x48127ffa7fff8000", - "0x482480017ff98000", + "0x482680017ff88000", "0x1", - "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0x5", - "0x480a7ff77fff8000", - "0x480080047ff18000", - "0x482480017ff08000", - "0x8", + "0x480a7ff97fff8000", "0x480680017fff8000", "0x1", - "0x480080067fee8000", - "0x480080077fed8000", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", "0x208b7fff7fff7ffe", - "0x40780017fff7fff", + "0xa0680017fff8000", "0x7", - "0x40780017fff7fff", + "0x482680017ff98000", + "0xfffffffffffffffffffffffffffff722", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x2f", + "0x4825800180007ff9", + "0x8de", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffa80007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffa8000", "0x1", + "0x480a7ffb7fff8000", "0x480680017fff8000", - "0x556e6578706563746564206572726f72", - "0x400080007ffe7fff", - "0x480a7ff77fff8000", - "0x48127ff07fff8000", - "0x48127ff07fff8000", + "0x0", + "0x480a7ffa7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", "0x480680017fff8000", "0x1", - "0x48127ffa7fff8000", - "0x482480017ff98000", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xe", + "0x480080007fff8000", + "0x400280007ffd7fff", + "0x48127ff97fff8000", + "0x48127ff77fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffc7fff8000", + "0x482680017ffd8000", "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd7", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", "0x208b7fff7fff7ffe", - "0x40780017fff7fff", - "0xa", "0x40780017fff7fff", "0x1", "0x480680017fff8000", - "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x4f7574206f6620676173", "0x400080007ffe7fff", - "0x480a7ff77fff8000", - "0x48127ff07fff8000", - "0x48127ff07fff8000", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", "0x480680017fff8000", "0x1", - "0x48127ffa7fff8000", - "0x482480017ff98000", + "0x48127ffb7fff8000", + "0x482480017ffa8000", "0x1", "0x208b7fff7fff7ffe", "0x40780017fff7fff", @@ -7486,7 +8038,7 @@ "0x48127ffa7fff8000", "0x48127ffa7fff8000", "0x1104800180018000", - "0x135b", + "0x13e9", "0x20680017fff7ffa", "0x384", "0x20680017fff7ffd", @@ -7590,7 +8142,7 @@ "0x48127ffa7fff8000", "0x480080007ff88000", "0x1104800180018000", - "0x13ac", + "0x143a", "0x20680017fff7ffa", "0x1a", "0x20680017fff7ffd", @@ -7722,7 +8274,7 @@ "0x48127ff97fff8000", "0x48127ff97fff8000", "0x1104800180018000", - "0x126f", + "0x12fd", "0x20680017fff7ffa", "0x165", "0x20680017fff7ffd", @@ -7822,7 +8374,7 @@ "0x48127ff87fff8000", "0x48127ff87fff8000", "0x1104800180018000", - "0x120b", + "0x1299", "0x20680017fff7ffa", "0x49", "0x20680017fff7ffd", @@ -8661,7 +9213,7 @@ "0x480a7fed7fff8000", "0x480a7fee7fff8000", "0x1104800180018000", - "0xfcd", + "0x105b", "0x20680017fff7ffa", "0xdc", "0x20680017fff7fff", @@ -8701,7 +9253,7 @@ "0x480a7ff27fff8000", "0x480a7ff37fff8000", "0x1104800180018000", - "0x1026", + "0x10b4", "0x20680017fff7ffa", "0xa2", "0x20680017fff7fff", @@ -8737,7 +9289,7 @@ "0x480a7ff57fff8000", "0x480a7ff67fff8000", "0x1104800180018000", - "0xf81", + "0x100f", "0x20680017fff7ffa", "0x78", "0x20680017fff7fff", @@ -8782,7 +9334,7 @@ "0x480a7ff97fff8000", "0x480a7ffa7fff8000", "0x1104800180018000", - "0xf54", + "0xfe2", "0x20680017fff7ffa", "0x45", "0x20680017fff7fff", @@ -9219,7 +9771,7 @@ "0x48127ffb7fff8000", "0x48127ffa7fff8000", "0x1104800180018000", - "0xeb7", + "0xf45", "0x20680017fff7ffb", "0xb4", "0x48127ff97fff8000", @@ -9231,7 +9783,7 @@ "0x480680017fff8000", "0x0", "0x1104800180018000", - "0xf04", + "0xf92", "0x20680017fff7ffd", "0xa1", "0x480680017fff8000", @@ -9427,13 +9979,13 @@ "0x480680017fff8000", "0x0", "0x1104800180018000", - "0xf3d", + "0xfcb", "0x20680017fff7ffd", "0x37", "0x1104800180018000", - "0x25df", + "0x266d", "0x482480017fff8000", - "0x25de", + "0x266c", "0x48127ff97fff8000", "0x480a7ffc7fff8000", "0x480a7ffd7fff8000", @@ -9441,7 +9993,7 @@ "0x48127ff87fff8000", "0x48127ffa7fff8000", "0x1104800180018000", - "0x1031", + "0x10bf", "0x20680017fff7ffc", "0x22", "0x48127fff7fff8000", @@ -9735,7 +10287,7 @@ "0x482480017ff48000", "0xbb448978bd42b984d7de5970bcaf5c43", "0x1104800180018000", - "0xf6c", + "0xffa", "0x20680017fff7ffd", "0x17", "0x20680017fff7ffe", @@ -10111,7 +10663,7 @@ "0x177e60492c5a8242f76f07bfe3661bd", "0x48127ff47fff8000", "0x1104800180018000", - "0xed0", + "0xf5e", "0x20680017fff7ffd", "0xc", "0x48127ffa7fff8000", @@ -12033,9 +12585,9 @@ "0x20680017fff7fff", "0x14d", "0x1104800180018000", - "0x1bbe", + "0x1c4c", "0x482480017fff8000", - "0x1bbd", + "0x1c4b", "0x480680017fff8000", "0x2", "0x482480017ffe8000", @@ -12117,7 +12669,7 @@ "0x480680017fff8000", "0x0", "0x1104800180018000", - "0xbd4", + "0xc62", "0x402580017fd38005", "0x1", "0x20680017fff7fff", @@ -12136,7 +12688,7 @@ "0x480680017fff8000", "0x1f", "0x1104800180018000", - "0xbe0", + "0xc6e", "0x20680017fff7ffb", "0x70", "0x48127ffa7fff8000", @@ -12149,7 +12701,7 @@ "0x480680017fff8000", "0x1f", "0x1104800180018000", - "0xbd3", + "0xc61", "0x20680017fff7ffb", "0x59", "0x48127ffa7fff8000", @@ -12162,7 +12714,7 @@ "0x480680017fff8000", "0x1f", "0x1104800180018000", - "0xbc6", + "0xc54", "0x20680017fff7ffb", "0x42", "0x48127ffa7fff8000", @@ -12175,7 +12727,7 @@ "0x480680017fff8000", "0x2", "0x1104800180018000", - "0xbb9", + "0xc47", "0x20680017fff7ffb", "0x2b", "0x40780017fff7fff", @@ -12197,7 +12749,7 @@ "0x482480017ff88000", "0x2", "0x1104800180018000", - "0x1013", + "0x10a1", "0x20680017fff7ffd", "0x9", "0x400180007fff8003", @@ -12440,6 +12992,148 @@ "0x480680017fff8000", "0x0", "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x400280007ff97fff", + "0x400380017ff97ff8", + "0x400380027ff97ffa", + "0x400380037ff97ffb", + "0x400380047ff97ffc", + "0x400380057ff97ffd", + "0x480280077ff98000", + "0x20680017fff7fff", + "0x1c", + "0x40780017fff7fff", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x46a6158a16a947e5916b2a2ca68501a45e93d7110e81aa2d6438b1c57c879a3", + "0x400080007ffe7fff", + "0x480680017fff8000", + "0x0", + "0x400080017ffd7fff", + "0x480680017fff8000", + "0x457870656374656420726576657274", + "0x400080027ffc7fff", + "0x480680017fff8000", + "0xf", + "0x400080037ffb7fff", + "0x480a7ff77fff8000", + "0x480280067ff98000", + "0x482680017ff98000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x48127ff77fff8000", + "0x482480017ff68000", + "0x4", + "0x208b7fff7fff7ffe", + "0x480280087ff98000", + "0x480280097ff98000", + "0x480280067ff98000", + "0x482680017ff98000", + "0xa", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x51", + "0x4824800180007ffc", + "0x1", + "0x480080007fff8000", + "0x4824800180007fff", + "0x454e545259504f494e545f4641494c4544", + "0x20680017fff7fff", + "0x3a", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1275130f95dda36bcbb6e9d28796c1d7e10b6e9fd5ed083e0ede4b12f613528", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400080007ff87fff", + "0x400080017ff87ff7", + "0x400080027ff87ffd", + "0x400080037ff87ffe", + "0x480080057ff88000", + "0x20680017fff7fff", + "0x22", + "0x480080067ff78000", + "0x480080047ff68000", + "0x482480017ff58000", + "0x7", + "0x20680017fff7ffd", + "0xe", + "0x40780017fff7fff", + "0x2", + "0x480a7ff77fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x76616c7565732073686f756c64206e6f74206368616e67652e", + "0x400080007ffe7fff", + "0x480a7ff77fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x5", + "0x480a7ff77fff8000", + "0x480080047ff18000", + "0x482480017ff08000", + "0x8", + "0x480680017fff8000", + "0x1", + "0x480080067fee8000", + "0x480080077fed8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x7", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x556e6578706563746564206572726f72", + "0x400080007ffe7fff", + "0x480a7ff77fff8000", + "0x48127ff07fff8000", + "0x48127ff07fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xa", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x480a7ff77fff8000", + "0x48127ff07fff8000", + "0x48127ff07fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", "0x48297ffc80007ffd", "0x20680017fff7fff", "0x4", @@ -19158,7 +19852,7 @@ 241, 180, 291, - 290, + 562, 171, 336, 178, @@ -19187,11 +19881,13 @@ 156, 128, 123, + 290, 161, 250, 187, 92, - 142, + 66, + 66, 126, 106, 205, @@ -19213,6 +19909,7 @@ 302, 466, 33, + 142, 185, 80, 129, @@ -19939,7 +20636,7 @@ { "TestLessThanOrEqual": { "lhs": { - "Immediate": "0x0" + "Immediate": "0x1ca2" }, "rhs": { "Deref": { @@ -19963,7 +20660,7 @@ "lhs": { "Deref": { "register": "FP", - "offset": 1 + "offset": 8 } }, "rhs": { @@ -20014,7 +20711,7 @@ "value": { "Deref": { "register": "FP", - "offset": 1 + "offset": 8 } }, "scalar": { @@ -20049,7 +20746,236 @@ ] ], [ - 862, + 881, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 7 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 885, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 895, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "FP", + "offset": 7 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 948, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 995, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1014, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x70d0" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1036, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 1050, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -5 + }, + "b": { + "Immediate": "0xa" + } + } + } + } + } + ] + ], + [ + 1053, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1079, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1146, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1161, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1175, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1196, [ { "AllocSegment": { @@ -20062,29 +20988,7 @@ ] ], [ - 881, - [ - { - "TestLessThanOrEqual": { - "lhs": { - "Immediate": "0x602c" - }, - "rhs": { - "Deref": { - "register": "AP", - "offset": -11 - } - }, - "dst": { - "register": "AP", - "offset": 0 - } - } - } - ] - ], - [ - 905, + 1210, [ { "AllocSegment": { @@ -20097,7 +21001,7 @@ ] ], [ - 923, + 1224, [ { "AllocSegment": { @@ -20110,7 +21014,7 @@ ] ], [ - 938, + 1245, [ { "AllocSegment": { @@ -20123,7 +21027,7 @@ ] ], [ - 952, + 1259, [ { "AllocSegment": { @@ -20136,33 +21040,7 @@ ] ], [ - 973, - [ - { - "AllocSegment": { - "dst": { - "register": "AP", - "offset": 0 - } - } - } - ] - ], - [ - 987, - [ - { - "AllocSegment": { - "dst": { - "register": "AP", - "offset": 0 - } - } - } - ] - ], - [ - 1002, + 1274, [ { "TestLessThanOrEqual": { @@ -20184,7 +21062,7 @@ ] ], [ - 1035, + 1307, [ { "TestLessThan": { @@ -20206,7 +21084,7 @@ ] ], [ - 1039, + 1311, [ { "LinearSplit": { @@ -20235,7 +21113,7 @@ ] ], [ - 1049, + 1321, [ { "LinearSplit": { @@ -20264,7 +21142,7 @@ ] ], [ - 1064, + 1336, [ { "AllocSegment": { @@ -20277,7 +21155,7 @@ ] ], [ - 1083, + 1355, [ { "TestLessThanOrEqual": { @@ -20299,7 +21177,7 @@ ] ], [ - 1104, + 1376, [ { "AllocSegment": { @@ -20312,7 +21190,7 @@ ] ], [ - 1122, + 1394, [ { "AllocSegment": { @@ -20325,7 +21203,7 @@ ] ], [ - 1144, + 1416, [ { "AllocSegment": { @@ -20338,7 +21216,7 @@ ] ], [ - 1158, + 1430, [ { "AllocSegment": { @@ -20351,7 +21229,7 @@ ] ], [ - 1175, + 1447, [ { "TestLessThanOrEqual": { @@ -20373,7 +21251,7 @@ ] ], [ - 1209, + 1481, [ { "TestLessThan": { @@ -20401,7 +21279,7 @@ ] ], [ - 1213, + 1485, [ { "LinearSplit": { @@ -20430,7 +21308,7 @@ ] ], [ - 1254, + 1526, [ { "AllocSegment": { @@ -20443,7 +21321,7 @@ ] ], [ - 1319, + 1591, [ { "AllocSegment": { @@ -20456,7 +21334,7 @@ ] ], [ - 1366, + 1638, [ { "AllocSegment": { @@ -20469,7 +21347,7 @@ ] ], [ - 1385, + 1657, [ { "TestLessThanOrEqual": { @@ -20491,7 +21369,7 @@ ] ], [ - 1412, + 1684, [ { "AllocSegment": { @@ -20504,7 +21382,7 @@ ] ], [ - 1430, + 1702, [ { "AllocSegment": { @@ -20517,7 +21395,7 @@ ] ], [ - 1445, + 1717, [ { "AllocSegment": { @@ -20530,7 +21408,7 @@ ] ], [ - 1459, + 1731, [ { "AllocSegment": { @@ -20543,7 +21421,7 @@ ] ], [ - 1480, + 1752, [ { "AllocSegment": { @@ -20556,7 +21434,7 @@ ] ], [ - 1494, + 1766, [ { "AllocSegment": { @@ -20569,7 +21447,7 @@ ] ], [ - 1509, + 1781, [ { "TestLessThanOrEqual": { @@ -20591,7 +21469,7 @@ ] ], [ - 1543, + 1815, [ { "TestLessThan": { @@ -20619,7 +21497,7 @@ ] ], [ - 1547, + 1819, [ { "LinearSplit": { @@ -20648,7 +21526,7 @@ ] ], [ - 1572, + 1844, [ { "AllocSegment": { @@ -20661,7 +21539,7 @@ ] ], [ - 1591, + 1863, [ { "TestLessThanOrEqual": { @@ -20683,7 +21561,7 @@ ] ], [ - 1610, + 1882, [ { "SystemCall": { @@ -20698,7 +21576,7 @@ ] ], [ - 1613, + 1885, [ { "AllocSegment": { @@ -20711,7 +21589,7 @@ ] ], [ - 1636, + 1908, [ { "AllocSegment": { @@ -20724,7 +21602,7 @@ ] ], [ - 1658, + 1930, [ { "AllocSegment": { @@ -20737,7 +21615,7 @@ ] ], [ - 1672, + 1944, [ { "AllocSegment": { @@ -20750,7 +21628,7 @@ ] ], [ - 1689, + 1961, [ { "TestLessThanOrEqual": { @@ -20772,7 +21650,7 @@ ] ], [ - 1788, + 2060, [ { "AllocSegment": { @@ -20785,7 +21663,7 @@ ] ], [ - 1807, + 2079, [ { "TestLessThanOrEqual": { @@ -20807,7 +21685,7 @@ ] ], [ - 1850, + 2122, [ { "AllocSegment": { @@ -20820,7 +21698,7 @@ ] ], [ - 1868, + 2140, [ { "AllocSegment": { @@ -20833,7 +21711,7 @@ ] ], [ - 1883, + 2155, [ { "AllocSegment": { @@ -20846,7 +21724,7 @@ ] ], [ - 1897, + 2169, [ { "AllocSegment": { @@ -20859,7 +21737,7 @@ ] ], [ - 1911, + 2183, [ { "AllocSegment": { @@ -20872,7 +21750,7 @@ ] ], [ - 1925, + 2197, [ { "AllocSegment": { @@ -20885,7 +21763,7 @@ ] ], [ - 1947, + 2219, [ { "AllocSegment": { @@ -20898,7 +21776,7 @@ ] ], [ - 1961, + 2233, [ { "AllocSegment": { @@ -20911,7 +21789,7 @@ ] ], [ - 1978, + 2250, [ { "TestLessThanOrEqual": { @@ -20933,7 +21811,7 @@ ] ], [ - 2012, + 2284, [ { "TestLessThan": { @@ -20955,7 +21833,7 @@ ] ], [ - 2016, + 2288, [ { "LinearSplit": { @@ -20984,7 +21862,7 @@ ] ], [ - 2026, + 2298, [ { "LinearSplit": { @@ -21013,7 +21891,7 @@ ] ], [ - 2079, + 2351, [ { "AllocSegment": { @@ -21026,7 +21904,7 @@ ] ], [ - 2126, + 2398, [ { "AllocSegment": { @@ -21039,7 +21917,7 @@ ] ], [ - 2145, + 2417, [ { "TestLessThanOrEqual": { @@ -21061,7 +21939,7 @@ ] ], [ - 2167, + 2439, [ { "SystemCall": { @@ -21076,7 +21954,7 @@ ] ], [ - 2188, + 2460, [ { "AllocSegment": { @@ -21089,7 +21967,7 @@ ] ], [ - 2203, + 2475, [ { "AllocSegment": { @@ -21102,7 +21980,7 @@ ] ], [ - 2217, + 2489, [ { "AllocSegment": { @@ -21115,7 +21993,7 @@ ] ], [ - 2238, + 2510, [ { "AllocSegment": { @@ -21128,7 +22006,7 @@ ] ], [ - 2252, + 2524, [ { "AllocSegment": { @@ -21141,7 +22019,7 @@ ] ], [ - 2267, + 2539, [ { "TestLessThanOrEqual": { @@ -21163,7 +22041,7 @@ ] ], [ - 2300, + 2572, [ { "TestLessThan": { @@ -21185,7 +22063,7 @@ ] ], [ - 2304, + 2576, [ { "LinearSplit": { @@ -21214,7 +22092,7 @@ ] ], [ - 2314, + 2586, [ { "LinearSplit": { @@ -21243,7 +22121,7 @@ ] ], [ - 2413, + 2685, [ { "AllocSegment": { @@ -21256,7 +22134,7 @@ ] ], [ - 2432, + 2704, [ { "TestLessThanOrEqual": { @@ -21278,7 +22156,7 @@ ] ], [ - 2461, + 2733, [ { "AllocSegment": { @@ -21291,7 +22169,7 @@ ] ], [ - 2476, + 2748, [ { "AllocSegment": { @@ -21304,7 +22182,7 @@ ] ], [ - 2490, + 2762, [ { "AllocSegment": { @@ -21317,7 +22195,7 @@ ] ], [ - 2504, + 2776, [ { "AllocSegment": { @@ -21330,7 +22208,7 @@ ] ], [ - 2518, + 2790, [ { "AllocSegment": { @@ -21343,7 +22221,7 @@ ] ], [ - 2539, + 2811, [ { "AllocSegment": { @@ -21356,7 +22234,7 @@ ] ], [ - 2553, + 2825, [ { "AllocSegment": { @@ -21369,7 +22247,7 @@ ] ], [ - 2568, + 2840, [ { "TestLessThanOrEqual": { @@ -21391,7 +22269,7 @@ ] ], [ - 2601, + 2873, [ { "TestLessThan": { @@ -21413,7 +22291,7 @@ ] ], [ - 2605, + 2877, [ { "LinearSplit": { @@ -21442,7 +22320,7 @@ ] ], [ - 2615, + 2887, [ { "LinearSplit": { @@ -21471,7 +22349,7 @@ ] ], [ - 2630, + 2902, [ { "AllocSegment": { @@ -21484,7 +22362,7 @@ ] ], [ - 2649, + 2921, [ { "TestLessThanOrEqual": { @@ -21506,7 +22384,7 @@ ] ], [ - 2668, + 2940, [ { "SystemCall": { @@ -21521,7 +22399,7 @@ ] ], [ - 2671, + 2943, [ { "AllocSegment": { @@ -21534,7 +22412,7 @@ ] ], [ - 2691, + 2963, [ { "AllocSegment": { @@ -21547,7 +22425,7 @@ ] ], [ - 2713, + 2985, [ { "AllocSegment": { @@ -21560,7 +22438,7 @@ ] ], [ - 2727, + 2999, [ { "AllocSegment": { @@ -21573,7 +22451,7 @@ ] ], [ - 2744, + 3016, [ { "TestLessThanOrEqual": { @@ -21595,7 +22473,7 @@ ] ], [ - 2799, + 3071, [ { "AllocSegment": { @@ -21608,7 +22486,7 @@ ] ], [ - 2846, + 3118, [ { "AllocSegment": { @@ -21621,7 +22499,7 @@ ] ], [ - 2865, + 3137, [ { "TestLessThanOrEqual": { @@ -21643,7 +22521,7 @@ ] ], [ - 2886, + 3158, [ { "SystemCall": { @@ -21658,7 +22536,7 @@ ] ], [ - 2889, + 3161, [ { "AllocSegment": { @@ -21671,7 +22549,7 @@ ] ], [ - 2909, + 3181, [ { "AllocSegment": { @@ -21684,7 +22562,7 @@ ] ], [ - 2924, + 3196, [ { "AllocSegment": { @@ -21697,7 +22575,7 @@ ] ], [ - 2938, + 3210, [ { "AllocSegment": { @@ -21710,7 +22588,7 @@ ] ], [ - 2952, + 3224, [ { "AllocSegment": { @@ -21723,7 +22601,7 @@ ] ], [ - 2967, + 3239, [ { "TestLessThanOrEqual": { @@ -21745,7 +22623,7 @@ ] ], [ - 2984, + 3256, [ { "AllocSegment": { @@ -21758,7 +22636,7 @@ ] ], [ - 3004, + 3276, [ { "TestLessThanOrEqual": { @@ -21780,7 +22658,7 @@ ] ], [ - 3016, + 3288, [ { "AllocFelt252Dict": { @@ -21795,7 +22673,7 @@ ] ], [ - 3035, + 3307, [ { "AllocSegment": { @@ -21808,7 +22686,7 @@ ] ], [ - 3046, + 3318, [ { "AllocSegment": { @@ -21821,7 +22699,7 @@ ] ], [ - 3062, + 3334, [ { "AllocSegment": { @@ -21834,7 +22712,7 @@ ] ], [ - 3080, + 3352, [ { "TestLessThanOrEqual": { @@ -21856,7 +22734,7 @@ ] ], [ - 3114, + 3386, [ { "TestLessThan": { @@ -21878,7 +22756,7 @@ ] ], [ - 3118, + 3390, [ { "LinearSplit": { @@ -21907,7 +22785,7 @@ ] ], [ - 3128, + 3400, [ { "LinearSplit": { @@ -21936,7 +22814,7 @@ ] ], [ - 3181, + 3453, [ { "AllocSegment": { @@ -21949,7 +22827,7 @@ ] ], [ - 3258, + 3530, [ { "AllocSegment": { @@ -21962,7 +22840,7 @@ ] ], [ - 3277, + 3549, [ { "TestLessThanOrEqual": { @@ -21984,7 +22862,7 @@ ] ], [ - 3303, + 3575, [ { "SystemCall": { @@ -21999,7 +22877,7 @@ ] ], [ - 3306, + 3578, [ { "AllocSegment": { @@ -22012,7 +22890,7 @@ ] ], [ - 3326, + 3598, [ { "AllocSegment": { @@ -22025,7 +22903,7 @@ ] ], [ - 3341, + 3613, [ { "AllocSegment": { @@ -22038,7 +22916,7 @@ ] ], [ - 3355, + 3627, [ { "AllocSegment": { @@ -22051,7 +22929,7 @@ ] ], [ - 3369, + 3641, [ { "AllocSegment": { @@ -22064,7 +22942,7 @@ ] ], [ - 3390, + 3662, [ { "AllocSegment": { @@ -22077,7 +22955,7 @@ ] ], [ - 3404, + 3676, [ { "AllocSegment": { @@ -22090,7 +22968,7 @@ ] ], [ - 3419, + 3691, [ { "TestLessThanOrEqual": { @@ -22112,7 +22990,7 @@ ] ], [ - 3436, + 3708, [ { "AllocSegment": { @@ -22125,7 +23003,7 @@ ] ], [ - 3455, + 3727, [ { "TestLessThanOrEqual": { @@ -22147,7 +23025,7 @@ ] ], [ - 3475, + 3747, [ { "AllocSegment": { @@ -22160,7 +23038,7 @@ ] ], [ - 3493, + 3765, [ { "AllocSegment": { @@ -22173,7 +23051,7 @@ ] ], [ - 3508, + 3780, [ { "AllocSegment": { @@ -22186,7 +23064,7 @@ ] ], [ - 3523, + 3795, [ { "TestLessThanOrEqual": { @@ -22208,7 +23086,7 @@ ] ], [ - 3540, + 3812, [ { "AllocSegment": { @@ -22221,7 +23099,7 @@ ] ], [ - 3559, + 3831, [ { "TestLessThanOrEqual": { @@ -22243,7 +23121,7 @@ ] ], [ - 3579, + 3851, [ { "AllocSegment": { @@ -22256,7 +23134,7 @@ ] ], [ - 3597, + 3869, [ { "AllocSegment": { @@ -22269,7 +23147,7 @@ ] ], [ - 3612, + 3884, [ { "AllocSegment": { @@ -22282,7 +23160,7 @@ ] ], [ - 3627, + 3899, [ { "TestLessThanOrEqual": { @@ -22304,7 +23182,7 @@ ] ], [ - 3644, + 3916, [ { "AllocSegment": { @@ -22317,7 +23195,7 @@ ] ], [ - 3669, + 3941, [ { "TestLessThanOrEqual": { @@ -22342,7 +23220,7 @@ ] ], [ - 3688, + 3960, [ { "AllocSegment": { @@ -22355,7 +23233,7 @@ ] ], [ - 3708, + 3980, [ { "AllocSegment": { @@ -22368,7 +23246,7 @@ ] ], [ - 3724, + 3996, [ { "AllocSegment": { @@ -22381,7 +23259,7 @@ ] ], [ - 3740, + 4012, [ { "TestLessThanOrEqual": { @@ -22403,7 +23281,7 @@ ] ], [ - 3757, + 4029, [ { "AllocSegment": { @@ -22416,7 +23294,7 @@ ] ], [ - 3776, + 4048, [ { "TestLessThanOrEqual": { @@ -22438,7 +23316,7 @@ ] ], [ - 3796, + 4068, [ { "AllocSegment": { @@ -22451,7 +23329,7 @@ ] ], [ - 3814, + 4086, [ { "AllocSegment": { @@ -22464,7 +23342,7 @@ ] ], [ - 3829, + 4101, [ { "AllocSegment": { @@ -22477,7 +23355,7 @@ ] ], [ - 3844, + 4116, [ { "TestLessThanOrEqual": { @@ -22499,7 +23377,7 @@ ] ], [ - 3903, + 4175, [ { "AllocSegment": { @@ -22512,7 +23390,7 @@ ] ], [ - 3922, + 4194, [ { "TestLessThanOrEqual": { @@ -22534,7 +23412,7 @@ ] ], [ - 3939, + 4211, [ { "AllocSegment": { @@ -22547,7 +23425,7 @@ ] ], [ - 3953, + 4225, [ { "AllocSegment": { @@ -22560,7 +23438,7 @@ ] ], [ - 3967, + 4239, [ { "AllocSegment": { @@ -22573,7 +23451,7 @@ ] ], [ - 3982, + 4254, [ { "AllocSegment": { @@ -22586,7 +23464,7 @@ ] ], [ - 3996, + 4268, [ { "AllocSegment": { @@ -22599,7 +23477,7 @@ ] ], [ - 4010, + 4282, [ { "AllocSegment": { @@ -22612,7 +23490,7 @@ ] ], [ - 4025, + 4297, [ { "TestLessThanOrEqual": { @@ -22634,7 +23512,7 @@ ] ], [ - 4058, + 4330, [ { "AllocSegment": { @@ -22647,7 +23525,7 @@ ] ], [ - 4105, + 4377, [ { "AllocSegment": { @@ -22660,7 +23538,7 @@ ] ], [ - 4124, + 4396, [ { "TestLessThanOrEqual": { @@ -22682,7 +23560,7 @@ ] ], [ - 4146, + 4418, [ { "AllocSegment": { @@ -22695,7 +23573,7 @@ ] ], [ - 4166, + 4438, [ { "AllocSegment": { @@ -22708,7 +23586,7 @@ ] ], [ - 4181, + 4453, [ { "AllocSegment": { @@ -22721,7 +23599,7 @@ ] ], [ - 4195, + 4467, [ { "AllocSegment": { @@ -22734,7 +23612,7 @@ ] ], [ - 4210, + 4482, [ { "TestLessThanOrEqual": { @@ -22756,7 +23634,7 @@ ] ], [ - 4227, + 4499, [ { "AllocSegment": { @@ -22769,7 +23647,7 @@ ] ], [ - 4246, + 4518, [ { "TestLessThanOrEqual": { @@ -22791,7 +23669,7 @@ ] ], [ - 4258, + 4530, [ { "AllocSegment": { @@ -22804,7 +23682,7 @@ ] ], [ - 4273, + 4545, [ { "AllocSegment": { @@ -22817,7 +23695,7 @@ ] ], [ - 4288, + 4560, [ { "AllocSegment": { @@ -22830,7 +23708,7 @@ ] ], [ - 4303, + 4575, [ { "TestLessThanOrEqual": { @@ -22852,7 +23730,7 @@ ] ], [ - 4341, + 4613, [ { "AllocSegment": { @@ -22865,7 +23743,7 @@ ] ], [ - 4360, + 4632, [ { "TestLessThanOrEqual": { @@ -22887,7 +23765,7 @@ ] ], [ - 4380, + 4652, [ { "AllocSegment": { @@ -22900,7 +23778,7 @@ ] ], [ - 4398, + 4670, [ { "AllocSegment": { @@ -22913,7 +23791,7 @@ ] ], [ - 4413, + 4685, [ { "AllocSegment": { @@ -22926,7 +23804,7 @@ ] ], [ - 4427, + 4699, [ { "AllocSegment": { @@ -22939,7 +23817,7 @@ ] ], [ - 4442, + 4714, [ { "TestLessThanOrEqual": { @@ -22961,7 +23839,7 @@ ] ], [ - 4480, + 4752, [ { "AllocSegment": { @@ -22974,7 +23852,7 @@ ] ], [ - 4499, + 4771, [ { "TestLessThanOrEqual": { @@ -22996,7 +23874,7 @@ ] ], [ - 4519, + 4791, [ { "AllocSegment": { @@ -23009,7 +23887,7 @@ ] ], [ - 4537, + 4809, [ { "AllocSegment": { @@ -23022,7 +23900,7 @@ ] ], [ - 4552, + 4824, [ { "AllocSegment": { @@ -23035,7 +23913,7 @@ ] ], [ - 4566, + 4838, [ { "AllocSegment": { @@ -23048,7 +23926,7 @@ ] ], [ - 4581, + 4853, [ { "TestLessThanOrEqual": { @@ -23070,7 +23948,7 @@ ] ], [ - 4614, + 4886, [ { "TestLessThan": { @@ -23092,7 +23970,7 @@ ] ], [ - 4618, + 4890, [ { "LinearSplit": { @@ -23121,7 +23999,7 @@ ] ], [ - 4628, + 4900, [ { "LinearSplit": { @@ -23150,7 +24028,7 @@ ] ], [ - 4685, + 4957, [ { "AllocSegment": { @@ -23163,7 +24041,7 @@ ] ], [ - 4704, + 4976, [ { "TestLessThanOrEqual": { @@ -23185,7 +24063,7 @@ ] ], [ - 4726, + 4998, [ { "AllocSegment": { @@ -23198,7 +24076,7 @@ ] ], [ - 4744, + 5016, [ { "SystemCall": { @@ -23213,7 +24091,7 @@ ] ], [ - 4750, + 5022, [ { "AllocSegment": { @@ -23226,7 +24104,7 @@ ] ], [ - 4769, + 5041, [ { "AllocSegment": { @@ -23239,7 +24117,7 @@ ] ], [ - 4784, + 5056, [ { "AllocSegment": { @@ -23252,7 +24130,7 @@ ] ], [ - 4798, + 5070, [ { "AllocSegment": { @@ -23265,7 +24143,7 @@ ] ], [ - 4819, + 5091, [ { "AllocSegment": { @@ -23278,7 +24156,7 @@ ] ], [ - 4833, + 5105, [ { "AllocSegment": { @@ -23291,7 +24169,7 @@ ] ], [ - 4848, + 5120, [ { "TestLessThanOrEqual": { @@ -23313,7 +24191,7 @@ ] ], [ - 4928, + 5200, [ { "AllocSegment": { @@ -23326,7 +24204,7 @@ ] ], [ - 4953, + 5225, [ { "TestLessThanOrEqual": { @@ -23351,7 +24229,7 @@ ] ], [ - 4975, + 5247, [ { "AllocSegment": { @@ -23364,7 +24242,7 @@ ] ], [ - 4995, + 5267, [ { "AllocSegment": { @@ -23377,7 +24255,7 @@ ] ], [ - 5011, + 5283, [ { "AllocSegment": { @@ -23390,7 +24268,7 @@ ] ], [ - 5026, + 5298, [ { "AllocSegment": { @@ -23403,7 +24281,7 @@ ] ], [ - 5041, + 5313, [ { "AllocSegment": { @@ -23416,7 +24294,7 @@ ] ], [ - 5056, + 5328, [ { "AllocSegment": { @@ -23429,7 +24307,7 @@ ] ], [ - 5072, + 5344, [ { "TestLessThanOrEqual": { @@ -23451,7 +24329,7 @@ ] ], [ - 5095, + 5367, [ { "AllocSegment": { @@ -23464,7 +24342,7 @@ ] ], [ - 5125, + 5397, [ { "TestLessThanOrEqual": { @@ -23489,7 +24367,7 @@ ] ], [ - 5148, + 5420, [ { "AllocSegment": { @@ -23502,7 +24380,7 @@ ] ], [ - 5170, + 5442, [ { "AllocSegment": { @@ -23515,7 +24393,7 @@ ] ], [ - 5187, + 5459, [ { "AllocSegment": { @@ -23528,7 +24406,7 @@ ] ], [ - 5203, + 5475, [ { "AllocSegment": { @@ -23541,7 +24419,7 @@ ] ], [ - 5220, + 5492, [ { "TestLessThanOrEqual": { @@ -23563,7 +24441,7 @@ ] ], [ - 5253, + 5525, [ { "TestLessThan": { @@ -23585,7 +24463,7 @@ ] ], [ - 5257, + 5529, [ { "LinearSplit": { @@ -23614,7 +24492,7 @@ ] ], [ - 5267, + 5539, [ { "LinearSplit": { @@ -23643,7 +24521,7 @@ ] ], [ - 5288, + 5560, [ { "AllocSegment": { @@ -23656,7 +24534,7 @@ ] ], [ - 5307, + 5579, [ { "TestLessThanOrEqual": { @@ -23678,7 +24556,7 @@ ] ], [ - 5319, + 5591, [ { "AllocSegment": { @@ -23691,7 +24569,7 @@ ] ], [ - 5339, + 5611, [ { "SystemCall": { @@ -23706,7 +24584,7 @@ ] ], [ - 5342, + 5614, [ { "AllocSegment": { @@ -23719,7 +24597,7 @@ ] ], [ - 5362, + 5634, [ { "AllocSegment": { @@ -23732,7 +24610,7 @@ ] ], [ - 5377, + 5649, [ { "AllocSegment": { @@ -23745,7 +24623,7 @@ ] ], [ - 5398, + 5670, [ { "AllocSegment": { @@ -23758,7 +24636,7 @@ ] ], [ - 5412, + 5684, [ { "AllocSegment": { @@ -23771,7 +24649,7 @@ ] ], [ - 5427, + 5699, [ { "TestLessThanOrEqual": { @@ -23793,7 +24671,7 @@ ] ], [ - 5444, + 5716, [ { "AllocSegment": { @@ -23806,7 +24684,7 @@ ] ], [ - 5467, + 5739, [ { "TestLessThanOrEqual": { @@ -23831,7 +24709,7 @@ ] ], [ - 5486, + 5758, [ { "AllocSegment": { @@ -23844,7 +24722,7 @@ ] ], [ - 5506, + 5778, [ { "AllocSegment": { @@ -23857,7 +24735,7 @@ ] ], [ - 5522, + 5794, [ { "AllocSegment": { @@ -23870,7 +24748,7 @@ ] ], [ - 5538, + 5810, [ { "TestLessThanOrEqual": { @@ -23892,7 +24770,195 @@ ] ], [ - 5576, + 5848, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5873, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -15 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5893, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5913, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5929, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5944, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5960, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5998, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6017, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x1220" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -12 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6029, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6049, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 6052, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6072, [ { "AllocSegment": { @@ -23905,22 +24971,10 @@ ] ], [ - 5601, + 6087, [ { - "TestLessThanOrEqual": { - "lhs": { - "Deref": { - "register": "AP", - "offset": -1 - } - }, - "rhs": { - "Deref": { - "register": "AP", - "offset": -15 - } - }, + "AllocSegment": { "dst": { "register": "AP", "offset": 0 @@ -23930,7 +24984,7 @@ ] ], [ - 5621, + 6101, [ { "AllocSegment": { @@ -23943,10 +24997,19 @@ ] ], [ - 5641, + 6116, [ { - "AllocSegment": { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, "dst": { "register": "AP", "offset": 0 @@ -23956,7 +25019,7 @@ ] ], [ - 5657, + 6133, [ { "AllocSegment": { @@ -23969,7 +25032,32 @@ ] ], [ - 5672, + 6164, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -13 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6184, [ { "AllocSegment": { @@ -23982,19 +25070,10 @@ ] ], [ - 5688, + 6208, [ { - "TestLessThanOrEqual": { - "lhs": { - "Immediate": "0x0" - }, - "rhs": { - "Deref": { - "register": "FP", - "offset": -6 - } - }, + "AllocSegment": { "dst": { "register": "AP", "offset": 0 @@ -24004,7 +25083,7 @@ ] ], [ - 5726, + 6226, [ { "AllocSegment": { @@ -24017,17 +25096,17 @@ ] ], [ - 5745, + 6244, [ { "TestLessThanOrEqual": { "lhs": { - "Immediate": "0x1220" + "Immediate": "0x0" }, "rhs": { "Deref": { - "register": "AP", - "offset": -12 + "register": "FP", + "offset": -6 } }, "dst": { @@ -24039,7 +25118,7 @@ ] ], [ - 5757, + 6261, [ { "AllocSegment": { @@ -24052,25 +25131,19 @@ ] ], [ - 5777, + 6281, [ { - "SystemCall": { - "system": { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { "Deref": { - "register": "FP", - "offset": -5 + "register": "AP", + "offset": -7 } - } - } - } - ] - ], - [ - 5780, - [ - { - "AllocSegment": { + }, "dst": { "register": "AP", "offset": 0 @@ -24080,7 +25153,7 @@ ] ], [ - 5800, + 6305, [ { "AllocSegment": { @@ -24093,7 +25166,7 @@ ] ], [ - 5815, + 6335, [ { "AllocSegment": { @@ -24106,7 +25179,7 @@ ] ], [ - 5829, + 6351, [ { "AllocSegment": { @@ -24119,7 +25192,7 @@ ] ], [ - 5844, + 6369, [ { "TestLessThanOrEqual": { @@ -24141,49 +25214,78 @@ ] ], [ - 5861, + 6403, [ { - "AllocSegment": { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, "dst": { "register": "AP", - "offset": 0 + "offset": 4 } } } ] ], [ - 5892, + 6407, [ { - "TestLessThanOrEqual": { - "lhs": { + "LinearSplit": { + "value": { "Deref": { "register": "AP", - "offset": -1 + "offset": 3 } }, - "rhs": { - "Deref": { - "register": "AP", - "offset": -13 - } + "scalar": { + "Immediate": "0x110000000000000000" }, - "dst": { + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { "register": "AP", - "offset": 0 + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 } } } ] ], [ - 5912, + 6417, [ { - "AllocSegment": { - "dst": { + "LinearSplit": { + "value": { + "Deref": { + "register": "FP", + "offset": 1 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { "register": "AP", "offset": 0 } @@ -24192,7 +25294,7 @@ ] ], [ - 5936, + 6470, [ { "AllocSegment": { @@ -24205,7 +25307,7 @@ ] ], [ - 5954, + 6517, [ { "AllocSegment": { @@ -24218,17 +25320,17 @@ ] ], [ - 5972, + 6536, [ { "TestLessThanOrEqual": { "lhs": { - "Immediate": "0x0" + "Immediate": "0x602c" }, "rhs": { "Deref": { - "register": "FP", - "offset": -6 + "register": "AP", + "offset": -11 } }, "dst": { @@ -24240,7 +25342,7 @@ ] ], [ - 5989, + 6560, [ { "AllocSegment": { @@ -24253,19 +25355,10 @@ ] ], [ - 6009, + 6578, [ { - "TestLessThanOrEqual": { - "lhs": { - "Immediate": "0x0" - }, - "rhs": { - "Deref": { - "register": "AP", - "offset": -7 - } - }, + "AllocSegment": { "dst": { "register": "AP", "offset": 0 @@ -24275,7 +25368,7 @@ ] ], [ - 6033, + 6593, [ { "AllocSegment": { @@ -24288,7 +25381,7 @@ ] ], [ - 6063, + 6607, [ { "AllocSegment": { @@ -24301,7 +25394,7 @@ ] ], [ - 6079, + 6628, [ { "AllocSegment": { @@ -24314,7 +25407,20 @@ ] ], [ - 6095, + 6642, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6657, [ { "TestLessThanOrEqual": { @@ -24336,7 +25442,7 @@ ] ], [ - 6154, + 6716, [ { "AllocSegment": { @@ -24349,7 +25455,7 @@ ] ], [ - 6173, + 6735, [ { "TestLessThanOrEqual": { @@ -24371,7 +25477,7 @@ ] ], [ - 6185, + 6747, [ { "AllocSegment": { @@ -24384,7 +25490,7 @@ ] ], [ - 6198, + 6760, [ { "AllocSegment": { @@ -24397,7 +25503,7 @@ ] ], [ - 6213, + 6775, [ { "AllocSegment": { @@ -24410,7 +25516,7 @@ ] ], [ - 6227, + 6789, [ { "AllocSegment": { @@ -24423,7 +25529,7 @@ ] ], [ - 6241, + 6803, [ { "AllocSegment": { @@ -24436,7 +25542,7 @@ ] ], [ - 6256, + 6818, [ { "TestLessThanOrEqual": { @@ -24458,7 +25564,7 @@ ] ], [ - 6310, + 6872, [ { "TestLessThan": { @@ -24480,7 +25586,7 @@ ] ], [ - 6314, + 6876, [ { "LinearSplit": { @@ -24509,7 +25615,7 @@ ] ], [ - 6324, + 6886, [ { "LinearSplit": { @@ -24538,7 +25644,7 @@ ] ], [ - 6360, + 6922, [ { "AllocSegment": { @@ -24551,7 +25657,7 @@ ] ], [ - 6379, + 6941, [ { "TestLessThanOrEqual": { @@ -24573,7 +25679,7 @@ ] ], [ - 6402, + 6964, [ { "SystemCall": { @@ -24588,7 +25694,7 @@ ] ], [ - 6405, + 6967, [ { "AllocSegment": { @@ -24601,7 +25707,7 @@ ] ], [ - 6427, + 6989, [ { "AllocSegment": { @@ -24614,7 +25720,7 @@ ] ], [ - 6442, + 7004, [ { "AllocSegment": { @@ -24627,7 +25733,7 @@ ] ], [ - 6463, + 7025, [ { "AllocSegment": { @@ -24640,7 +25746,7 @@ ] ], [ - 6477, + 7039, [ { "AllocSegment": { @@ -24653,7 +25759,7 @@ ] ], [ - 6491, + 7053, [ { "AllocSegment": { @@ -24666,7 +25772,7 @@ ] ], [ - 6506, + 7068, [ { "TestLessThanOrEqual": { @@ -24688,96 +25794,7 @@ ] ], [ - 6565, - [ - { - "AllocSegment": { - "dst": { - "register": "AP", - "offset": 0 - } - } - } - ] - ], - [ - 6584, - [ - { - "TestLessThanOrEqual": { - "lhs": { - "Immediate": "0x1414" - }, - "rhs": { - "Deref": { - "register": "AP", - "offset": -17 - } - }, - "dst": { - "register": "AP", - "offset": 0 - } - } - } - ] - ], - [ - 6610, - [ - { - "SystemCall": { - "system": { - "Deref": { - "register": "FP", - "offset": -5 - } - } - } - } - ] - ], - [ - 6613, - [ - { - "AllocSegment": { - "dst": { - "register": "AP", - "offset": 0 - } - } - } - ] - ], - [ - 6635, - [ - { - "AllocSegment": { - "dst": { - "register": "AP", - "offset": 0 - } - } - } - ] - ], - [ - 6650, - [ - { - "AllocSegment": { - "dst": { - "register": "AP", - "offset": 0 - } - } - } - ] - ], - [ - 6664, + 7127, [ { "AllocSegment": { @@ -24790,10 +25807,19 @@ ] ], [ - 6678, + 7146, [ { - "AllocSegment": { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x1414" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -17 + } + }, "dst": { "register": "AP", "offset": 0 @@ -24803,19 +25829,25 @@ ] ], [ - 6693, + 7172, [ { - "TestLessThanOrEqual": { - "lhs": { - "Immediate": "0x942" - }, - "rhs": { + "SystemCall": { + "system": { "Deref": { "register": "FP", - "offset": -8 + "offset": -5 } - }, + } + } + } + ] + ], + [ + 7175, + [ + { + "AllocSegment": { "dst": { "register": "AP", "offset": 0 @@ -24825,7 +25857,7 @@ ] ], [ - 6765, + 7197, [ { "AllocSegment": { @@ -24838,22 +25870,68 @@ ] ], [ - 6793, + 7212, [ { - "SystemCall": { - "system": { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7226, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7240, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7255, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x942" + }, + "rhs": { "Deref": { "register": "FP", - "offset": -7 + "offset": -8 } + }, + "dst": { + "register": "AP", + "offset": 0 } } } ] ], [ - 6798, + 7327, [ { "AllocSegment": { @@ -24866,22 +25944,29 @@ ] ], [ - 6849, + 7347, [ { - "SystemCall": { - "system": { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x8de" + }, + "rhs": { "Deref": { - "register": "AP", - "offset": -8 + "register": "FP", + "offset": -7 } + }, + "dst": { + "register": "AP", + "offset": 0 } } } ] ], [ - 6870, + 7399, [ { "AllocSegment": { @@ -24894,10 +25979,19 @@ ] ], [ - 6897, + 7413, [ { - "AllocSegment": { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x8de" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, "dst": { "register": "AP", "offset": 0 @@ -24907,7 +26001,7 @@ ] ], [ - 6913, + 7465, [ { "AllocSegment": { @@ -24920,7 +26014,7 @@ ] ], [ - 6927, + 7479, [ { "AllocSegment": { @@ -24933,7 +26027,7 @@ ] ], [ - 6943, + 7495, [ { "SystemCall": { @@ -24948,7 +26042,7 @@ ] ], [ - 6952, + 7504, [ { "SystemCall": { @@ -24969,7 +26063,7 @@ ] ], [ - 6965, + 7517, [ { "SystemCall": { @@ -24990,7 +26084,7 @@ ] ], [ - 6982, + 7534, [ { "SystemCall": { @@ -25011,7 +26105,7 @@ ] ], [ - 6985, + 7537, [ { "AllocSegment": { @@ -25024,7 +26118,7 @@ ] ], [ - 7053, + 7605, [ { "TestLessThanOrEqual": { @@ -25046,7 +26140,7 @@ ] ], [ - 7078, + 7630, [ { "SystemCall": { @@ -25061,7 +26155,7 @@ ] ], [ - 7086, + 7638, [ { "TestLessThan": { @@ -25092,7 +26186,7 @@ ] ], [ - 7111, + 7663, [ { "AllocSegment": { @@ -25105,7 +26199,7 @@ ] ], [ - 7144, + 7696, [ { "AllocSegment": { @@ -25118,7 +26212,7 @@ ] ], [ - 7181, + 7733, [ { "TestLessThan": { @@ -25146,7 +26240,7 @@ ] ], [ - 7185, + 7737, [ { "LinearSplit": { @@ -25175,7 +26269,7 @@ ] ], [ - 7227, + 7779, [ { "TestLessThan": { @@ -25203,7 +26297,7 @@ ] ], [ - 7231, + 7783, [ { "LinearSplit": { @@ -25232,7 +26326,7 @@ ] ], [ - 7272, + 7824, [ { "TestLessThan": { @@ -25254,7 +26348,7 @@ ] ], [ - 7276, + 7828, [ { "LinearSplit": { @@ -25283,7 +26377,7 @@ ] ], [ - 7286, + 7838, [ { "LinearSplit": { @@ -25312,7 +26406,7 @@ ] ], [ - 7410, + 7962, [ { "TestLessThan": { @@ -25334,7 +26428,7 @@ ] ], [ - 7414, + 7966, [ { "LinearSplit": { @@ -25363,7 +26457,7 @@ ] ], [ - 7424, + 7976, [ { "LinearSplit": { @@ -25392,7 +26486,7 @@ ] ], [ - 7456, + 8008, [ { "TestLessThan": { @@ -25414,7 +26508,7 @@ ] ], [ - 7458, + 8010, [ { "DivMod": { @@ -25440,7 +26534,7 @@ ] ], [ - 7578, + 8130, [ { "AllocSegment": { @@ -25453,7 +26547,7 @@ ] ], [ - 7692, + 8244, [ { "TestLessThan": { @@ -25475,7 +26569,7 @@ ] ], [ - 7694, + 8246, [ { "DivMod": { @@ -25501,7 +26595,7 @@ ] ], [ - 7747, + 8299, [ { "TestLessThan": { @@ -25529,7 +26623,7 @@ ] ], [ - 7751, + 8303, [ { "LinearSplit": { @@ -25558,7 +26652,7 @@ ] ], [ - 7793, + 8345, [ { "TestLessThan": { @@ -25586,7 +26680,7 @@ ] ], [ - 7797, + 8349, [ { "LinearSplit": { @@ -25615,7 +26709,7 @@ ] ], [ - 8575, + 9127, [ { "SystemCall": { @@ -25630,7 +26724,7 @@ ] ], [ - 8808, + 9360, [ { "AllocSegment": { @@ -25643,7 +26737,7 @@ ] ], [ - 8822, + 9374, [ { "AllocSegment": { @@ -25656,7 +26750,7 @@ ] ], [ - 8836, + 9388, [ { "AllocSegment": { @@ -25669,7 +26763,7 @@ ] ], [ - 8900, + 9452, [ { "AllocSegment": { @@ -25682,7 +26776,7 @@ ] ], [ - 8914, + 9466, [ { "AllocSegment": { @@ -25695,7 +26789,7 @@ ] ], [ - 8937, + 9489, [ { "AllocSegment": { @@ -25708,7 +26802,7 @@ ] ], [ - 8961, + 9513, [ { "SystemCall": { @@ -25723,7 +26817,7 @@ ] ], [ - 8964, + 9516, [ { "AllocSegment": { @@ -25736,7 +26830,7 @@ ] ], [ - 8980, + 9532, [ { "SystemCall": { @@ -25757,7 +26851,7 @@ ] ], [ - 9017, + 9569, [ { "GetSegmentArenaIndex": { @@ -25776,7 +26870,7 @@ ] ], [ - 9058, + 9610, [ { "AllocSegment": { @@ -25789,7 +26883,7 @@ ] ], [ - 9066, + 9618, [ { "InitSquashData": { @@ -25824,7 +26918,7 @@ ] ], [ - 9085, + 9637, [ { "GetCurrentAccessIndex": { @@ -25839,7 +26933,7 @@ ] ], [ - 9098, + 9650, [ { "ShouldSkipSquashLoop": { @@ -25852,7 +26946,7 @@ ] ], [ - 9100, + 9652, [ { "GetCurrentAccessDelta": { @@ -25865,7 +26959,7 @@ ] ], [ - 9111, + 9663, [ { "ShouldContinueSquashLoop": { @@ -25878,7 +26972,7 @@ ] ], [ - 9125, + 9677, [ { "GetNextDictKey": { @@ -25891,7 +26985,7 @@ ] ], [ - 9144, + 9696, [ { "AssertLeFindSmallArcs": { @@ -25924,7 +27018,7 @@ ] ], [ - 9156, + 9708, [ { "AssertLeIsFirstArcExcluded": { @@ -25937,7 +27031,7 @@ ] ], [ - 9168, + 9720, [ { "AssertLeIsSecondArcExcluded": { @@ -25950,7 +27044,7 @@ ] ], [ - 9199, + 9751, [ { "AllocSegment": { @@ -25963,7 +27057,7 @@ ] ], [ - 9207, + 9759, [ { "AllocSegment": { @@ -25976,7 +27070,7 @@ ] ], [ - 9238, + 9790, [ { "SystemCall": { @@ -25991,7 +27085,7 @@ ] ], [ - 9252, + 9804, [ { "AllocSegment": { @@ -26004,7 +27098,7 @@ ] ], [ - 9272, + 9824, [ { "AllocSegment": { @@ -26017,7 +27111,7 @@ ] ], [ - 9286, + 9838, [ { "AllocSegment": { @@ -26030,7 +27124,7 @@ ] ], [ - 9300, + 9852, [ { "SystemCall": { @@ -26045,7 +27139,7 @@ ] ], [ - 9303, + 9855, [ { "AllocSegment": { @@ -26058,7 +27152,7 @@ ] ], [ - 9326, + 9878, [ { "TestLessThan": { @@ -26083,7 +27177,7 @@ ] ], [ - 9354, + 9906, [ { "AllocSegment": { @@ -26096,7 +27190,7 @@ ] ], [ - 9368, + 9920, [ { "AllocSegment": { @@ -26109,7 +27203,7 @@ ] ], [ - 9411, + 9963, [ { "AllocSegment": { @@ -26122,7 +27216,7 @@ ] ], [ - 9450, + 10002, [ { "AllocSegment": { @@ -26135,7 +27229,7 @@ ] ], [ - 9510, + 10062, [ { "SystemCall": { @@ -26150,7 +27244,7 @@ ] ], [ - 9520, + 10072, [ { "AllocSegment": { @@ -26163,7 +27257,7 @@ ] ], [ - 9551, + 10103, [ { "SystemCall": { @@ -26178,7 +27272,7 @@ ] ], [ - 9554, + 10106, [ { "AllocSegment": { @@ -26191,7 +27285,7 @@ ] ], [ - 9578, + 10130, [ { "TestLessThan": { @@ -26216,7 +27310,7 @@ ] ], [ - 9612, + 10164, [ { "SystemCall": { @@ -26231,7 +27325,7 @@ ] ], [ - 9627, + 10179, [ { "SystemCall": { @@ -26246,7 +27340,7 @@ ] ], [ - 9673, + 10225, [ { "AllocSegment": { @@ -26259,7 +27353,7 @@ ] ], [ - 9692, + 10244, [ { "DivMod": { @@ -26288,7 +27382,7 @@ ] ], [ - 9698, + 10250, [ { "TestLessThan": { @@ -26310,7 +27404,7 @@ ] ], [ - 9749, + 10301, [ { "AllocSegment": { @@ -26323,7 +27417,7 @@ ] ], [ - 9780, + 10332, [ { "AllocSegment": { @@ -26336,7 +27430,7 @@ ] ], [ - 9805, + 10357, [ { "AllocSegment": { @@ -26349,7 +27443,7 @@ ] ], [ - 9820, + 10372, [ { "AllocSegment": { @@ -26362,7 +27456,7 @@ ] ], [ - 9862, + 10414, [ { "SystemCall": { @@ -26377,7 +27471,7 @@ ] ], [ - 9874, + 10426, [ { "AllocSegment": { @@ -26390,7 +27484,7 @@ ] ], [ - 9904, + 10456, [ { "SystemCall": { @@ -26405,7 +27499,7 @@ ] ], [ - 9909, + 10461, [ { "AllocSegment": { @@ -26418,7 +27512,7 @@ ] ], [ - 9932, + 10484, [ { "TestLessThan": { @@ -26443,7 +27537,7 @@ ] ], [ - 9966, + 10518, [ { "SystemCall": { @@ -26458,7 +27552,7 @@ ] ], [ - 9981, + 10533, [ { "SystemCall": { @@ -26473,7 +27567,7 @@ ] ], [ - 10029, + 10581, [ { "AllocSegment": { @@ -26486,7 +27580,7 @@ ] ], [ - 10047, + 10599, [ { "DivMod": { @@ -26515,7 +27609,7 @@ ] ], [ - 10053, + 10605, [ { "TestLessThan": { @@ -26537,7 +27631,7 @@ ] ], [ - 10082, + 10634, [ { "SystemCall": { @@ -26552,7 +27646,7 @@ ] ], [ - 10132, + 10684, [ { "AllocSegment": { @@ -26565,7 +27659,7 @@ ] ], [ - 10170, + 10722, [ { "AllocSegment": { @@ -26578,7 +27672,7 @@ ] ], [ - 10197, + 10749, [ { "AllocSegment": { @@ -26591,7 +27685,7 @@ ] ], [ - 10213, + 10765, [ { "AllocSegment": { @@ -26604,7 +27698,7 @@ ] ], [ - 10239, + 10791, [ { "TestLessThanOrEqual": { @@ -26626,7 +27720,7 @@ ] ], [ - 10253, + 10805, [ { "TestLessThan": { @@ -26648,7 +27742,7 @@ ] ], [ - 10328, + 10880, [ { "TestLessThan": { @@ -26670,7 +27764,7 @@ ] ], [ - 10332, + 10884, [ { "LinearSplit": { @@ -26699,7 +27793,7 @@ ] ], [ - 10342, + 10894, [ { "LinearSplit": { @@ -26728,7 +27822,7 @@ ] ], [ - 10360, + 10912, [ { "SystemCall": { @@ -26743,7 +27837,7 @@ ] ], [ - 10378, + 10930, [ { "AllocSegment": { @@ -26756,7 +27850,7 @@ ] ], [ - 10397, + 10949, [ { "TestLessThan": { @@ -26778,7 +27872,7 @@ ] ], [ - 10401, + 10953, [ { "LinearSplit": { @@ -26807,7 +27901,7 @@ ] ], [ - 10411, + 10963, [ { "LinearSplit": { @@ -26836,7 +27930,7 @@ ] ], [ - 10429, + 10981, [ { "SystemCall": { @@ -26851,7 +27945,7 @@ ] ], [ - 10447, + 10999, [ { "AllocSegment": { @@ -26864,7 +27958,7 @@ ] ], [ - 10478, + 11030, [ { "AllocSegment": { @@ -26877,7 +27971,7 @@ ] ], [ - 10502, + 11054, [ { "AllocSegment": { @@ -26890,7 +27984,7 @@ ] ], [ - 10516, + 11068, [ { "AllocSegment": { @@ -26903,7 +27997,7 @@ ] ], [ - 10530, + 11082, [ { "AllocSegment": { @@ -26916,7 +28010,7 @@ ] ], [ - 10544, + 11096, [ { "AllocSegment": { @@ -26929,7 +28023,7 @@ ] ], [ - 10559, + 11111, [ { "AllocSegment": { @@ -26942,7 +28036,7 @@ ] ], [ - 10574, + 11126, [ { "TestLessThanOrEqual": { @@ -26964,7 +28058,7 @@ ] ], [ - 10588, + 11140, [ { "AllocSegment": { @@ -26977,7 +28071,7 @@ ] ], [ - 10608, + 11160, [ { "AllocSegment": { @@ -26990,7 +28084,7 @@ ] ], [ - 10622, + 11174, [ { "TestLessThanOrEqual": { @@ -27012,7 +28106,7 @@ ] ], [ - 10652, + 11204, [ { "AllocSegment": { @@ -27025,7 +28119,7 @@ ] ], [ - 10671, + 11223, [ { "TestLessThan": { @@ -27047,7 +28141,7 @@ ] ], [ - 10675, + 11227, [ { "LinearSplit": { @@ -27076,7 +28170,7 @@ ] ], [ - 10686, + 11238, [ { "LinearSplit": { @@ -27105,7 +28199,7 @@ ] ], [ - 10712, + 11264, [ { "SystemCall": { @@ -27120,7 +28214,7 @@ ] ], [ - 10727, + 11279, [ { "SystemCall": { @@ -27141,7 +28235,7 @@ ] ], [ - 10735, + 11287, [ { "TestLessThan": { @@ -27163,7 +28257,7 @@ ] ], [ - 10739, + 11291, [ { "LinearSplit": { @@ -27192,7 +28286,7 @@ ] ], [ - 10750, + 11302, [ { "LinearSplit": { @@ -27221,7 +28315,7 @@ ] ], [ - 10780, + 11332, [ { "SystemCall": { @@ -27242,7 +28336,7 @@ ] ], [ - 10796, + 11348, [ { "SystemCall": { @@ -27263,7 +28357,7 @@ ] ], [ - 10904, + 11456, [ { "TestLessThan": { @@ -27285,7 +28379,7 @@ ] ], [ - 10906, + 11458, [ { "DivMod": { @@ -27311,7 +28405,7 @@ ] ], [ - 10951, + 11503, [ { "TestLessThan": { @@ -27333,7 +28427,7 @@ ] ], [ - 10953, + 11505, [ { "DivMod": { @@ -27359,7 +28453,7 @@ ] ], [ - 11062, + 11614, [ { "TestLessThan": { @@ -27381,7 +28475,7 @@ ] ], [ - 11066, + 11618, [ { "LinearSplit": { @@ -27410,7 +28504,7 @@ ] ], [ - 11077, + 11629, [ { "LinearSplit": { @@ -27439,7 +28533,7 @@ ] ], [ - 11103, + 11655, [ { "SystemCall": { @@ -27454,7 +28548,7 @@ ] ], [ - 11118, + 11670, [ { "SystemCall": { @@ -27475,7 +28569,7 @@ ] ], [ - 11125, + 11677, [ { "TestLessThan": { @@ -27497,7 +28591,7 @@ ] ], [ - 11127, + 11679, [ { "DivMod": { @@ -27523,7 +28617,7 @@ ] ], [ - 11148, + 11700, [ { "TestLessThan": { @@ -27545,7 +28639,7 @@ ] ], [ - 11150, + 11702, [ { "DivMod": { @@ -27571,7 +28665,7 @@ ] ], [ - 11180, + 11732, [ { "TestLessThan": { @@ -27593,7 +28687,7 @@ ] ], [ - 11184, + 11736, [ { "LinearSplit": { @@ -27622,7 +28716,7 @@ ] ], [ - 11195, + 11747, [ { "LinearSplit": { @@ -27651,7 +28745,7 @@ ] ], [ - 11226, + 11778, [ { "SystemCall": { @@ -27666,7 +28760,7 @@ ] ], [ - 11241, + 11793, [ { "SystemCall": { @@ -27687,7 +28781,7 @@ ] ], [ - 11285, + 11837, [ { "AllocSegment": { @@ -27700,7 +28794,7 @@ ] ], [ - 11304, + 11856, [ { "AllocSegment": { @@ -27713,7 +28807,7 @@ ] ], [ - 11386, + 11938, [ { "RandomEcPoint": { @@ -27741,7 +28835,7 @@ ] ], [ - 11450, + 12002, [ { "RandomEcPoint": { @@ -27769,7 +28863,7 @@ ] ], [ - 11520, + 12072, [ { "AllocSegment": { @@ -27782,7 +28876,7 @@ ] ], [ - 11546, + 12098, [ { "SystemCall": { @@ -27797,7 +28891,7 @@ ] ], [ - 11563, + 12115, [ { "SystemCall": { @@ -27818,7 +28912,7 @@ ] ], [ - 11605, + 12157, [ { "AllocSegment": { @@ -27831,7 +28925,7 @@ ] ], [ - 11622, + 12174, [ { "AllocSegment": { @@ -27844,7 +28938,7 @@ ] ], [ - 11641, + 12193, [ { "SystemCall": { @@ -27859,7 +28953,7 @@ ] ], [ - 11651, + 12203, [ { "TestLessThan": { @@ -27881,7 +28975,7 @@ ] ], [ - 11655, + 12207, [ { "LinearSplit": { @@ -27910,7 +29004,7 @@ ] ], [ - 11666, + 12218, [ { "LinearSplit": { @@ -27939,7 +29033,7 @@ ] ], [ - 11710, + 12262, [ { "SystemCall": { @@ -27960,7 +29054,7 @@ ] ], [ - 11725, + 12277, [ { "SystemCall": { @@ -27981,7 +29075,7 @@ ] ], [ - 11735, + 12287, [ { "TestLessThan": { @@ -28006,7 +29100,7 @@ ] ], [ - 11750, + 12302, [ { "TestLessThan": { @@ -28031,7 +29125,7 @@ ] ], [ - 11766, + 12318, [ { "TestLessThan": { @@ -28053,7 +29147,7 @@ ] ], [ - 11770, + 12322, [ { "LinearSplit": { @@ -28082,7 +29176,7 @@ ] ], [ - 11781, + 12333, [ { "LinearSplit": { @@ -28111,7 +29205,7 @@ ] ], [ - 11810, + 12362, [ { "SystemCall": { @@ -28126,7 +29220,7 @@ ] ], [ - 11826, + 12378, [ { "SystemCall": { @@ -28147,7 +29241,7 @@ ] ], [ - 11868, + 12420, [ { "AllocSegment": { @@ -28160,7 +29254,7 @@ ] ], [ - 11886, + 12438, [ { "AllocSegment": { @@ -28173,7 +29267,7 @@ ] ], [ - 11988, + 12540, [ { "AllocSegment": { @@ -28186,7 +29280,7 @@ ] ], [ - 12063, + 12615, [ { "EvalCircuit": { @@ -28219,7 +29313,7 @@ ] ], [ - 12120, + 12672, [ { "AllocSegment": { @@ -28232,7 +29326,7 @@ ] ], [ - 12176, + 12728, [ { "AllocSegment": { @@ -28245,7 +29339,7 @@ ] ], [ - 12269, + 12821, [ { "AllocSegment": { @@ -28258,7 +29352,7 @@ ] ], [ - 12290, + 12842, [ { "AllocSegment": { @@ -28271,7 +29365,7 @@ ] ], [ - 12361, + 12913, [ { "AllocSegment": { @@ -28284,7 +29378,7 @@ ] ], [ - 12389, + 12941, [ { "AllocSegment": { @@ -28297,7 +29391,89 @@ ] ], [ - 12460, + 12998, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -7 + } + } + } + } + ] + ], + [ + 13003, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13054, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -8 + } + } + } + } + ] + ], + [ + 13075, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13102, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13118, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13154, [ { "TestLessThan": { @@ -28325,7 +29501,7 @@ ] ], [ - 12464, + 13158, [ { "LinearSplit": { @@ -28354,7 +29530,7 @@ ] ], [ - 12486, + 13180, [ { "TestLessThanOrEqual": { @@ -28379,7 +29555,7 @@ ] ], [ - 12500, + 13194, [ { "TestLessThan": { @@ -28401,7 +29577,7 @@ ] ], [ - 12510, + 13204, [ { "TestLessThanOrEqual": { @@ -28426,7 +29602,7 @@ ] ], [ - 12533, + 13227, [ { "AllocSegment": { @@ -28439,7 +29615,7 @@ ] ], [ - 12554, + 13248, [ { "AllocSegment": { @@ -28452,7 +29628,7 @@ ] ], [ - 12575, + 13269, [ { "AllocSegment": { @@ -28465,7 +29641,7 @@ ] ], [ - 12623, + 13317, [ { "TestLessThanOrEqual": { @@ -28487,7 +29663,7 @@ ] ], [ - 12683, + 13377, [ { "AllocSegment": { @@ -28500,7 +29676,7 @@ ] ], [ - 12703, + 13397, [ { "TestLessThanOrEqual": { @@ -28522,7 +29698,7 @@ ] ], [ - 12782, + 13476, [ { "AllocSegment": { @@ -28535,7 +29711,7 @@ ] ], [ - 12812, + 13506, [ { "AllocSegment": { @@ -28548,7 +29724,7 @@ ] ], [ - 12832, + 13526, [ { "TestLessThanOrEqual": { @@ -28570,7 +29746,7 @@ ] ], [ - 12933, + 13627, [ { "AllocSegment": { @@ -28583,7 +29759,7 @@ ] ], [ - 12963, + 13657, [ { "AllocSegment": { @@ -28596,7 +29772,7 @@ ] ], [ - 12983, + 13677, [ { "TestLessThanOrEqual": { @@ -28618,7 +29794,7 @@ ] ], [ - 13054, + 13748, [ { "AllocSegment": { @@ -28631,7 +29807,7 @@ ] ], [ - 13075, + 13769, [ { "DivMod": { @@ -28660,7 +29836,7 @@ ] ], [ - 13133, + 13827, [ { "AllocSegment": { @@ -28673,7 +29849,7 @@ ] ], [ - 13186, + 13880, [ { "AllocSegment": { @@ -28686,7 +29862,7 @@ ] ], [ - 13199, + 13893, [ { "DivMod": { @@ -28715,7 +29891,7 @@ ] ], [ - 13207, + 13901, [ { "TestLessThan": { @@ -28746,7 +29922,7 @@ ] ], [ - 13224, + 13918, [ { "AllocSegment": { @@ -28759,7 +29935,7 @@ ] ], [ - 13256, + 13950, [ { "TestLessThan": { @@ -28781,7 +29957,7 @@ ] ], [ - 13273, + 13967, [ { "AllocSegment": { @@ -28794,7 +29970,7 @@ ] ], [ - 13289, + 13983, [ { "TestLessThan": { @@ -28825,7 +30001,7 @@ ] ], [ - 13311, + 14005, [ { "AllocSegment": { @@ -28838,7 +30014,7 @@ ] ], [ - 13368, + 14062, [ { "DivMod": { @@ -28867,7 +30043,7 @@ ] ], [ - 13377, + 14071, [ { "TestLessThan": { @@ -28889,7 +30065,7 @@ ] ], [ - 13387, + 14081, [ { "TestLessThan": { @@ -28920,7 +30096,7 @@ ] ], [ - 13409, + 14103, [ { "AllocSegment": { @@ -28933,7 +30109,7 @@ ] ], [ - 13424, + 14118, [ { "AllocSegment": { @@ -28946,7 +30122,7 @@ ] ], [ - 13449, + 14143, [ { "TestLessThan": { @@ -28977,7 +30153,7 @@ ] ], [ - 13463, + 14157, [ { "DivMod": { @@ -29006,7 +30182,7 @@ ] ], [ - 13480, + 14174, [ { "TestLessThan": { @@ -29028,7 +30204,7 @@ ] ], [ - 13492, + 14186, [ { "TestLessThan": { @@ -29050,7 +30226,7 @@ ] ], [ - 13502, + 14196, [ { "TestLessThan": { @@ -29081,7 +30257,7 @@ ] ], [ - 13525, + 14219, [ { "AllocSegment": { @@ -29094,7 +30270,7 @@ ] ], [ - 13540, + 14234, [ { "AllocSegment": { @@ -29107,7 +30283,7 @@ ] ], [ - 13555, + 14249, [ { "AllocSegment": { @@ -29120,7 +30296,7 @@ ] ], [ - 13570, + 14264, [ { "AllocSegment": { @@ -29133,7 +30309,7 @@ ] ], [ - 13583, + 14277, [ { "TestLessThanOrEqual": { @@ -29155,7 +30331,7 @@ ] ], [ - 13593, + 14287, [ { "TestLessThanOrEqualAddress": { @@ -29186,7 +30362,7 @@ ] ], [ - 13630, + 14324, [ { "SystemCall": { @@ -29201,7 +30377,7 @@ ] ], [ - 13663, + 14357, [ { "AllocSegment": { @@ -29214,7 +30390,7 @@ ] ], [ - 13697, + 14391, [ { "TestLessThan": { @@ -29236,7 +30412,7 @@ ] ], [ - 13719, + 14413, [ { "TestLessThan": { @@ -29258,7 +30434,7 @@ ] ], [ - 13756, + 14450, [ { "TestLessThan": { @@ -29280,7 +30456,7 @@ ] ], [ - 13778, + 14472, [ { "TestLessThan": { @@ -29302,7 +30478,7 @@ ] ], [ - 13854, + 14548, [ { "AllocSegment": { @@ -29315,7 +30491,7 @@ ] ], [ - 13919, + 14613, [ { "TestLessThan": { @@ -29337,7 +30513,7 @@ ] ], [ - 13943, + 14637, [ { "TestLessThan": { @@ -29359,7 +30535,7 @@ ] ], [ - 13984, + 14678, [ { "TestLessThan": { @@ -29381,7 +30557,7 @@ ] ], [ - 14010, + 14704, [ { "TestLessThan": { @@ -29403,7 +30579,7 @@ ] ], [ - 14054, + 14748, [ { "U256InvModN": { @@ -29460,7 +30636,7 @@ ] ], [ - 14072, + 14766, [ { "WideMul128": { @@ -29657,7 +30833,7 @@ ] ], [ - 14125, + 14819, [ { "WideMul128": { @@ -29710,7 +30886,7 @@ ] ], [ - 14129, + 14823, [ { "TestLessThan": { @@ -29732,7 +30908,7 @@ ] ], [ - 14143, + 14837, [ { "TestLessThan": { @@ -29754,7 +30930,7 @@ ] ], [ - 14156, + 14850, [ { "DivMod": { @@ -29780,7 +30956,7 @@ ] ], [ - 14166, + 14860, [ { "DivMod": { @@ -29806,7 +30982,7 @@ ] ], [ - 14177, + 14871, [ { "DivMod": { @@ -29832,7 +31008,7 @@ ] ], [ - 14186, + 14880, [ { "DivMod": { @@ -29858,7 +31034,7 @@ ] ], [ - 14196, + 14890, [ { "DivMod": { @@ -29884,7 +31060,7 @@ ] ], [ - 14207, + 14901, [ { "DivMod": { @@ -29910,7 +31086,7 @@ ] ], [ - 14216, + 14910, [ { "DivMod": { @@ -29936,7 +31112,7 @@ ] ], [ - 14226, + 14920, [ { "DivMod": { @@ -29962,7 +31138,7 @@ ] ], [ - 14237, + 14931, [ { "DivMod": { @@ -29988,7 +31164,7 @@ ] ], [ - 14246, + 14940, [ { "DivMod": { @@ -30014,7 +31190,7 @@ ] ], [ - 14256, + 14950, [ { "DivMod": { @@ -30040,7 +31216,7 @@ ] ], [ - 14267, + 14961, [ { "DivMod": { @@ -30066,7 +31242,7 @@ ] ], [ - 14276, + 14970, [ { "DivMod": { @@ -30092,7 +31268,7 @@ ] ], [ - 14286, + 14980, [ { "DivMod": { @@ -30118,7 +31294,7 @@ ] ], [ - 14297, + 14991, [ { "DivMod": { @@ -30144,7 +31320,7 @@ ] ], [ - 14306, + 15000, [ { "DivMod": { @@ -30170,7 +31346,7 @@ ] ], [ - 14316, + 15010, [ { "DivMod": { @@ -30196,7 +31372,7 @@ ] ], [ - 14327, + 15021, [ { "DivMod": { @@ -30222,7 +31398,7 @@ ] ], [ - 14336, + 15030, [ { "DivMod": { @@ -30248,7 +31424,7 @@ ] ], [ - 14346, + 15040, [ { "DivMod": { @@ -30274,7 +31450,7 @@ ] ], [ - 14357, + 15051, [ { "DivMod": { @@ -30300,7 +31476,7 @@ ] ], [ - 14366, + 15060, [ { "DivMod": { @@ -30326,7 +31502,7 @@ ] ], [ - 14376, + 15070, [ { "DivMod": { @@ -30352,7 +31528,7 @@ ] ], [ - 14387, + 15081, [ { "DivMod": { @@ -30378,7 +31554,7 @@ ] ], [ - 14408, + 15102, [ { "Uint512DivModByUint256": { @@ -30447,7 +31623,7 @@ ] ], [ - 14426, + 15120, [ { "WideMul128": { @@ -30572,7 +31748,7 @@ ] ], [ - 14455, + 15149, [ { "TestLessThan": { @@ -30597,7 +31773,7 @@ ] ], [ - 14467, + 15161, [ { "TestLessThan": { @@ -30622,7 +31798,7 @@ ] ], [ - 14482, + 15176, [ { "DivMod": { @@ -30648,7 +31824,7 @@ ] ], [ - 14492, + 15186, [ { "DivMod": { @@ -30674,7 +31850,7 @@ ] ], [ - 14503, + 15197, [ { "DivMod": { @@ -30700,7 +31876,7 @@ ] ], [ - 14512, + 15206, [ { "DivMod": { @@ -30726,7 +31902,7 @@ ] ], [ - 14522, + 15216, [ { "DivMod": { @@ -30752,7 +31928,7 @@ ] ], [ - 14533, + 15227, [ { "DivMod": { @@ -30778,7 +31954,7 @@ ] ], [ - 14542, + 15236, [ { "DivMod": { @@ -30804,7 +31980,7 @@ ] ], [ - 14552, + 15246, [ { "DivMod": { @@ -30830,7 +32006,7 @@ ] ], [ - 14563, + 15257, [ { "DivMod": { @@ -30856,7 +32032,7 @@ ] ], [ - 14572, + 15266, [ { "DivMod": { @@ -30882,7 +32058,7 @@ ] ], [ - 14582, + 15276, [ { "DivMod": { @@ -30908,7 +32084,7 @@ ] ], [ - 14593, + 15287, [ { "DivMod": { @@ -30934,7 +32110,7 @@ ] ], [ - 14602, + 15296, [ { "DivMod": { @@ -30960,7 +32136,7 @@ ] ], [ - 14612, + 15306, [ { "DivMod": { @@ -30986,7 +32162,7 @@ ] ], [ - 14623, + 15317, [ { "DivMod": { @@ -31012,7 +32188,7 @@ ] ], [ - 14644, + 15338, [ { "Uint512DivModByUint256": { @@ -31081,7 +32257,7 @@ ] ], [ - 14662, + 15356, [ { "WideMul128": { @@ -31206,7 +32382,7 @@ ] ], [ - 14691, + 15385, [ { "TestLessThan": { @@ -31231,7 +32407,7 @@ ] ], [ - 14703, + 15397, [ { "TestLessThan": { @@ -31256,7 +32432,7 @@ ] ], [ - 14718, + 15412, [ { "DivMod": { @@ -31282,7 +32458,7 @@ ] ], [ - 14728, + 15422, [ { "DivMod": { @@ -31308,7 +32484,7 @@ ] ], [ - 14739, + 15433, [ { "DivMod": { @@ -31334,7 +32510,7 @@ ] ], [ - 14748, + 15442, [ { "DivMod": { @@ -31360,7 +32536,7 @@ ] ], [ - 14758, + 15452, [ { "DivMod": { @@ -31386,7 +32562,7 @@ ] ], [ - 14769, + 15463, [ { "DivMod": { @@ -31412,7 +32588,7 @@ ] ], [ - 14778, + 15472, [ { "DivMod": { @@ -31438,7 +32614,7 @@ ] ], [ - 14788, + 15482, [ { "DivMod": { @@ -31464,7 +32640,7 @@ ] ], [ - 14799, + 15493, [ { "DivMod": { @@ -31490,7 +32666,7 @@ ] ], [ - 14808, + 15502, [ { "DivMod": { @@ -31516,7 +32692,7 @@ ] ], [ - 14818, + 15512, [ { "DivMod": { @@ -31542,7 +32718,7 @@ ] ], [ - 14829, + 15523, [ { "DivMod": { @@ -31568,7 +32744,7 @@ ] ], [ - 14838, + 15532, [ { "DivMod": { @@ -31594,7 +32770,7 @@ ] ], [ - 14848, + 15542, [ { "DivMod": { @@ -31620,7 +32796,7 @@ ] ], [ - 14859, + 15553, [ { "DivMod": { @@ -31646,7 +32822,7 @@ ] ], [ - 14886, + 15580, [ { "SystemCall": { @@ -31661,7 +32837,7 @@ ] ], [ - 14903, + 15597, [ { "SystemCall": { @@ -31676,7 +32852,7 @@ ] ], [ - 14915, + 15609, [ { "SystemCall": { @@ -31697,7 +32873,7 @@ ] ], [ - 14926, + 15620, [ { "SystemCall": { @@ -31718,7 +32894,7 @@ ] ], [ - 14936, + 15630, [ { "SystemCall": { @@ -31739,7 +32915,7 @@ ] ], [ - 15021, + 15715, [ { "AllocSegment": { @@ -31752,7 +32928,7 @@ ] ], [ - 15050, + 15744, [ { "DivMod": { @@ -31778,7 +32954,7 @@ ] ], [ - 15060, + 15754, [ { "DivMod": { @@ -31804,7 +32980,7 @@ ] ], [ - 15071, + 15765, [ { "DivMod": { @@ -31830,7 +33006,7 @@ ] ], [ - 15080, + 15774, [ { "DivMod": { @@ -31856,7 +33032,7 @@ ] ], [ - 15090, + 15784, [ { "DivMod": { @@ -31882,7 +33058,7 @@ ] ], [ - 15101, + 15795, [ { "DivMod": { @@ -31908,7 +33084,7 @@ ] ], [ - 15110, + 15804, [ { "AllocSegment": { @@ -31921,7 +33097,7 @@ ] ], [ - 15179, + 15873, [ { "TestLessThan": { @@ -31952,7 +33128,7 @@ ] ], [ - 15194, + 15888, [ { "TestLessThan": { @@ -31974,7 +33150,7 @@ ] ], [ - 15213, + 15907, [ { "TestLessThan": { @@ -31996,7 +33172,7 @@ ] ], [ - 15232, + 15926, [ { "TestLessThan": { @@ -32018,7 +33194,7 @@ ] ], [ - 15242, + 15936, [ { "TestLessThan": { @@ -32040,7 +33216,7 @@ ] ], [ - 15244, + 15938, [ { "DivMod": { @@ -32066,7 +33242,7 @@ ] ], [ - 15281, + 15975, [ { "TestLessThan": { @@ -32088,7 +33264,7 @@ ] ], [ - 15300, + 15994, [ { "AllocSegment": { @@ -32101,7 +33277,7 @@ ] ], [ - 15311, + 16005, [ { "DivMod": { @@ -32130,7 +33306,7 @@ ] ], [ - 15317, + 16011, [ { "TestLessThan": { @@ -32152,7 +33328,7 @@ ] ], [ - 15331, + 16025, [ { "TestLessThan": { @@ -32174,7 +33350,7 @@ ] ], [ - 15345, + 16039, [ { "TestLessThan": { @@ -32196,7 +33372,7 @@ ] ], [ - 15356, + 16050, [ { "TestLessThan": { @@ -32218,7 +33394,7 @@ ] ], [ - 15385, + 16079, [ { "AllocSegment": { @@ -32231,7 +33407,7 @@ ] ], [ - 15410, + 16104, [ { "TestLessThan": { @@ -32253,7 +33429,7 @@ ] ], [ - 15414, + 16108, [ { "LinearSplit": { @@ -32282,7 +33458,7 @@ ] ], [ - 15424, + 16118, [ { "LinearSplit": { @@ -32311,7 +33487,7 @@ ] ], [ - 15444, + 16138, [ { "AllocSegment": { @@ -32324,7 +33500,7 @@ ] ], [ - 15465, + 16159, [ { "AllocSegment": { @@ -32337,7 +33513,7 @@ ] ], [ - 15486, + 16180, [ { "AllocSegment": { @@ -32350,7 +33526,7 @@ ] ], [ - 15506, + 16200, [ { "TestLessThan": { @@ -32372,7 +33548,7 @@ ] ], [ - 15508, + 16202, [ { "DivMod": { @@ -32398,7 +33574,7 @@ ] ], [ - 15552, + 16246, [ { "AllocSegment": { @@ -32411,7 +33587,7 @@ ] ], [ - 15563, + 16257, [ { "DivMod": { @@ -32440,7 +33616,7 @@ ] ], [ - 15569, + 16263, [ { "TestLessThan": { @@ -32462,7 +33638,7 @@ ] ], [ - 15583, + 16277, [ { "TestLessThan": { @@ -32484,7 +33660,7 @@ ] ], [ - 15601, + 16295, [ { "TestLessThan": { @@ -32506,7 +33682,7 @@ ] ], [ - 15614, + 16308, [ { "TestLessThan": { @@ -32528,7 +33704,7 @@ ] ], [ - 15625, + 16319, [ { "TestLessThan": { @@ -32550,7 +33726,7 @@ ] ], [ - 15654, + 16348, [ { "AllocSegment": { @@ -32563,7 +33739,7 @@ ] ], [ - 15679, + 16373, [ { "TestLessThan": { @@ -32585,7 +33761,7 @@ ] ], [ - 15683, + 16377, [ { "LinearSplit": { @@ -32614,7 +33790,7 @@ ] ], [ - 15693, + 16387, [ { "LinearSplit": { @@ -32643,7 +33819,7 @@ ] ], [ - 15713, + 16407, [ { "AllocSegment": { @@ -32656,7 +33832,7 @@ ] ], [ - 15734, + 16428, [ { "AllocSegment": { @@ -32669,7 +33845,7 @@ ] ], [ - 15755, + 16449, [ { "AllocSegment": { @@ -32682,7 +33858,7 @@ ] ], [ - 15784, + 16478, [ { "TestLessThan": { @@ -32704,7 +33880,7 @@ ] ], [ - 15786, + 16480, [ { "DivMod": { @@ -32730,7 +33906,7 @@ ] ], [ - 15823, + 16517, [ { "TestLessThan": { @@ -32752,7 +33928,7 @@ ] ], [ - 15834, + 16528, [ { "TestLessThan": { @@ -32774,7 +33950,7 @@ ] ], [ - 15845, + 16539, [ { "TestLessThan": { @@ -32796,7 +33972,7 @@ ] ], [ - 15874, + 16568, [ { "AllocSegment": { @@ -32809,7 +33985,7 @@ ] ], [ - 15899, + 16593, [ { "TestLessThan": { @@ -32831,7 +34007,7 @@ ] ], [ - 15903, + 16597, [ { "LinearSplit": { @@ -32860,7 +34036,7 @@ ] ], [ - 15913, + 16607, [ { "LinearSplit": { @@ -32889,7 +34065,7 @@ ] ], [ - 15939, + 16633, [ { "AllocSegment": { @@ -32902,7 +34078,7 @@ ] ], [ - 15960, + 16654, [ { "AllocSegment": { @@ -32915,7 +34091,7 @@ ] ], [ - 15982, + 16676, [ { "AllocSegment": { @@ -32928,7 +34104,7 @@ ] ], [ - 16004, + 16698, [ { "TestLessThan": { @@ -32950,7 +34126,7 @@ ] ], [ - 16015, + 16709, [ { "TestLessThan": { @@ -32972,7 +34148,7 @@ ] ], [ - 16044, + 16738, [ { "AllocSegment": { @@ -32985,7 +34161,7 @@ ] ], [ - 16069, + 16763, [ { "TestLessThan": { @@ -33007,7 +34183,7 @@ ] ], [ - 16073, + 16767, [ { "LinearSplit": { @@ -33036,7 +34212,7 @@ ] ], [ - 16083, + 16777, [ { "LinearSplit": { @@ -33065,7 +34241,7 @@ ] ], [ - 16106, + 16800, [ { "AllocSegment": { @@ -33078,7 +34254,7 @@ ] ], [ - 16151, + 16845, [ { "TestLessThan": { @@ -33100,7 +34276,7 @@ ] ], [ - 16162, + 16856, [ { "TestLessThan": { @@ -33122,7 +34298,7 @@ ] ], [ - 16191, + 16885, [ { "AllocSegment": { @@ -33135,7 +34311,7 @@ ] ], [ - 16214, + 16908, [ { "TestLessThan": { @@ -33166,7 +34342,7 @@ ] ], [ - 16238, + 16932, [ { "AllocSegment": { @@ -33179,7 +34355,7 @@ ] ], [ - 16282, + 16976, [ { "AllocSegment": { @@ -33192,7 +34368,7 @@ ] ], [ - 16309, + 17003, [ { "TestLessThanOrEqual": { @@ -33214,7 +34390,7 @@ ] ], [ - 16361, + 17055, [ { "AllocSegment": { @@ -33227,7 +34403,7 @@ ] ], [ - 16418, + 17112, [ { "TestLessThan": { @@ -33255,7 +34431,7 @@ ] ], [ - 16422, + 17116, [ { "LinearSplit": { @@ -33284,7 +34460,7 @@ ] ], [ - 16464, + 17158, [ { "TestLessThan": { @@ -33306,7 +34482,7 @@ ] ], [ - 16466, + 17160, [ { "DivMod": { @@ -33332,7 +34508,7 @@ ] ], [ - 16553, + 17247, [ { "DivMod": { @@ -33361,7 +34537,7 @@ ] ], [ - 16559, + 17253, [ { "TestLessThan": { @@ -33383,7 +34559,7 @@ ] ], [ - 16570, + 17264, [ { "TestLessThan": { @@ -33405,7 +34581,7 @@ ] ], [ - 16580, + 17274, [ { "TestLessThan": { @@ -33427,7 +34603,7 @@ ] ], [ - 16594, + 17288, [ { "DivMod": { @@ -33456,7 +34632,7 @@ ] ], [ - 16600, + 17294, [ { "TestLessThan": { @@ -33478,7 +34654,7 @@ ] ], [ - 16614, + 17308, [ { "TestLessThan": { @@ -33500,7 +34676,7 @@ ] ], [ - 16624, + 17318, [ { "TestLessThan": { @@ -33522,7 +34698,7 @@ ] ], [ - 16646, + 17340, [ { "AllocSegment": { @@ -33535,7 +34711,7 @@ ] ], [ - 16660, + 17354, [ { "AllocSegment": { @@ -33548,7 +34724,7 @@ ] ], [ - 16678, + 17372, [ { "AllocSegment": { @@ -33561,7 +34737,7 @@ ] ], [ - 16692, + 17386, [ { "AllocSegment": { @@ -33574,7 +34750,7 @@ ] ], [ - 16708, + 17402, [ { "TestLessThanOrEqual": { @@ -33596,7 +34772,7 @@ ] ], [ - 16735, + 17429, [ { "TestLessThan": { @@ -33618,7 +34794,7 @@ ] ], [ - 16752, + 17446, [ { "AllocSegment": { @@ -33631,7 +34807,7 @@ ] ], [ - 16777, + 17471, [ { "AllocSegment": { @@ -33644,7 +34820,7 @@ ] ], [ - 17037, + 17731, [ { "SystemCall": { @@ -33659,7 +34835,7 @@ ] ], [ - 17063, + 17757, [ { "SystemCall": { @@ -33674,7 +34850,7 @@ ] ], [ - 17077, + 17771, [ { "U256InvModN": { @@ -33731,7 +34907,7 @@ ] ], [ - 17095, + 17789, [ { "WideMul128": { @@ -33928,7 +35104,7 @@ ] ], [ - 17148, + 17842, [ { "WideMul128": { @@ -33981,7 +35157,7 @@ ] ], [ - 17152, + 17846, [ { "TestLessThan": { @@ -34003,7 +35179,7 @@ ] ], [ - 17166, + 17860, [ { "TestLessThan": { @@ -34025,7 +35201,7 @@ ] ], [ - 17179, + 17873, [ { "DivMod": { @@ -34051,7 +35227,7 @@ ] ], [ - 17189, + 17883, [ { "DivMod": { @@ -34077,7 +35253,7 @@ ] ], [ - 17200, + 17894, [ { "DivMod": { @@ -34103,7 +35279,7 @@ ] ], [ - 17209, + 17903, [ { "DivMod": { @@ -34129,7 +35305,7 @@ ] ], [ - 17219, + 17913, [ { "DivMod": { @@ -34155,7 +35331,7 @@ ] ], [ - 17230, + 17924, [ { "DivMod": { @@ -34181,7 +35357,7 @@ ] ], [ - 17239, + 17933, [ { "DivMod": { @@ -34207,7 +35383,7 @@ ] ], [ - 17249, + 17943, [ { "DivMod": { @@ -34233,7 +35409,7 @@ ] ], [ - 17260, + 17954, [ { "DivMod": { @@ -34259,7 +35435,7 @@ ] ], [ - 17269, + 17963, [ { "DivMod": { @@ -34285,7 +35461,7 @@ ] ], [ - 17279, + 17973, [ { "DivMod": { @@ -34311,7 +35487,7 @@ ] ], [ - 17290, + 17984, [ { "DivMod": { @@ -34337,7 +35513,7 @@ ] ], [ - 17299, + 17993, [ { "DivMod": { @@ -34363,7 +35539,7 @@ ] ], [ - 17309, + 18003, [ { "DivMod": { @@ -34389,7 +35565,7 @@ ] ], [ - 17320, + 18014, [ { "DivMod": { @@ -34415,7 +35591,7 @@ ] ], [ - 17329, + 18023, [ { "DivMod": { @@ -34441,7 +35617,7 @@ ] ], [ - 17339, + 18033, [ { "DivMod": { @@ -34467,7 +35643,7 @@ ] ], [ - 17350, + 18044, [ { "DivMod": { @@ -34493,7 +35669,7 @@ ] ], [ - 17359, + 18053, [ { "DivMod": { @@ -34519,7 +35695,7 @@ ] ], [ - 17369, + 18063, [ { "DivMod": { @@ -34545,7 +35721,7 @@ ] ], [ - 17380, + 18074, [ { "DivMod": { @@ -34571,7 +35747,7 @@ ] ], [ - 17389, + 18083, [ { "DivMod": { @@ -34597,7 +35773,7 @@ ] ], [ - 17399, + 18093, [ { "DivMod": { @@ -34623,7 +35799,7 @@ ] ], [ - 17410, + 18104, [ { "DivMod": { @@ -34649,7 +35825,7 @@ ] ], [ - 17431, + 18125, [ { "Uint512DivModByUint256": { @@ -34718,7 +35894,7 @@ ] ], [ - 17449, + 18143, [ { "WideMul128": { @@ -34843,7 +36019,7 @@ ] ], [ - 17478, + 18172, [ { "TestLessThan": { @@ -34868,7 +36044,7 @@ ] ], [ - 17490, + 18184, [ { "TestLessThan": { @@ -34893,7 +36069,7 @@ ] ], [ - 17505, + 18199, [ { "DivMod": { @@ -34919,7 +36095,7 @@ ] ], [ - 17515, + 18209, [ { "DivMod": { @@ -34945,7 +36121,7 @@ ] ], [ - 17526, + 18220, [ { "DivMod": { @@ -34971,7 +36147,7 @@ ] ], [ - 17535, + 18229, [ { "DivMod": { @@ -34997,7 +36173,7 @@ ] ], [ - 17545, + 18239, [ { "DivMod": { @@ -35023,7 +36199,7 @@ ] ], [ - 17556, + 18250, [ { "DivMod": { @@ -35049,7 +36225,7 @@ ] ], [ - 17565, + 18259, [ { "DivMod": { @@ -35075,7 +36251,7 @@ ] ], [ - 17575, + 18269, [ { "DivMod": { @@ -35101,7 +36277,7 @@ ] ], [ - 17586, + 18280, [ { "DivMod": { @@ -35127,7 +36303,7 @@ ] ], [ - 17595, + 18289, [ { "DivMod": { @@ -35153,7 +36329,7 @@ ] ], [ - 17605, + 18299, [ { "DivMod": { @@ -35179,7 +36355,7 @@ ] ], [ - 17616, + 18310, [ { "DivMod": { @@ -35205,7 +36381,7 @@ ] ], [ - 17625, + 18319, [ { "DivMod": { @@ -35231,7 +36407,7 @@ ] ], [ - 17635, + 18329, [ { "DivMod": { @@ -35257,7 +36433,7 @@ ] ], [ - 17646, + 18340, [ { "DivMod": { @@ -35283,7 +36459,7 @@ ] ], [ - 17658, + 18352, [ { "TestLessThan": { @@ -35305,7 +36481,7 @@ ] ], [ - 17683, + 18377, [ { "TestLessThan": { @@ -35327,7 +36503,7 @@ ] ], [ - 17703, + 18397, [ { "TestLessThan": { @@ -35349,7 +36525,7 @@ ] ], [ - 17739, + 18433, [ { "Uint512DivModByUint256": { @@ -35418,7 +36594,7 @@ ] ], [ - 17757, + 18451, [ { "WideMul128": { @@ -35543,7 +36719,7 @@ ] ], [ - 17786, + 18480, [ { "TestLessThan": { @@ -35568,7 +36744,7 @@ ] ], [ - 17798, + 18492, [ { "TestLessThan": { @@ -35593,7 +36769,7 @@ ] ], [ - 17813, + 18507, [ { "DivMod": { @@ -35619,7 +36795,7 @@ ] ], [ - 17823, + 18517, [ { "DivMod": { @@ -35645,7 +36821,7 @@ ] ], [ - 17834, + 18528, [ { "DivMod": { @@ -35671,7 +36847,7 @@ ] ], [ - 17843, + 18537, [ { "DivMod": { @@ -35697,7 +36873,7 @@ ] ], [ - 17853, + 18547, [ { "DivMod": { @@ -35723,7 +36899,7 @@ ] ], [ - 17864, + 18558, [ { "DivMod": { @@ -35749,7 +36925,7 @@ ] ], [ - 17873, + 18567, [ { "DivMod": { @@ -35775,7 +36951,7 @@ ] ], [ - 17883, + 18577, [ { "DivMod": { @@ -35801,7 +36977,7 @@ ] ], [ - 17894, + 18588, [ { "DivMod": { @@ -35827,7 +37003,7 @@ ] ], [ - 17903, + 18597, [ { "DivMod": { @@ -35853,7 +37029,7 @@ ] ], [ - 17913, + 18607, [ { "DivMod": { @@ -35879,7 +37055,7 @@ ] ], [ - 17924, + 18618, [ { "DivMod": { @@ -35905,7 +37081,7 @@ ] ], [ - 17933, + 18627, [ { "DivMod": { @@ -35931,7 +37107,7 @@ ] ], [ - 17943, + 18637, [ { "DivMod": { @@ -35957,7 +37133,7 @@ ] ], [ - 17954, + 18648, [ { "DivMod": { @@ -35983,7 +37159,7 @@ ] ], [ - 17974, + 18668, [ { "SystemCall": { @@ -35998,7 +37174,7 @@ ] ], [ - 17986, + 18680, [ { "SystemCall": { @@ -36019,7 +37195,7 @@ ] ], [ - 17997, + 18691, [ { "SystemCall": { @@ -36040,7 +37216,7 @@ ] ], [ - 18043, + 18737, [ { "AllocSegment": { @@ -36053,7 +37229,7 @@ ] ], [ - 18059, + 18753, [ { "DivMod": { @@ -36079,7 +37255,7 @@ ] ], [ - 18069, + 18763, [ { "DivMod": { @@ -36105,7 +37281,7 @@ ] ], [ - 18080, + 18774, [ { "DivMod": { @@ -36131,7 +37307,7 @@ ] ], [ - 18089, + 18783, [ { "DivMod": { @@ -36157,7 +37333,7 @@ ] ], [ - 18099, + 18793, [ { "DivMod": { @@ -36183,7 +37359,7 @@ ] ], [ - 18110, + 18804, [ { "DivMod": { @@ -36209,7 +37385,7 @@ ] ], [ - 18119, + 18813, [ { "AllocSegment": { @@ -36222,7 +37398,7 @@ ] ], [ - 18136, + 18830, [ { "AllocSegment": { @@ -36235,7 +37411,7 @@ ] ], [ - 18193, + 18887, [ { "SystemCall": { @@ -36250,7 +37426,7 @@ ] ], [ - 18200, + 18894, [ { "AllocConstantSize": { @@ -36266,7 +37442,7 @@ ] ], [ - 18204, + 18898, [ { "AllocSegment": { @@ -36279,7 +37455,7 @@ ] ], [ - 18239, + 18933, [ { "SystemCall": { @@ -36294,7 +37470,7 @@ ] ], [ - 18312, + 19006, [ { "DivMod": { @@ -36323,7 +37499,7 @@ ] ], [ - 18318, + 19012, [ { "TestLessThan": { @@ -36345,7 +37521,7 @@ ] ], [ - 18385, + 19079, [ { "WideMul128": { @@ -36374,7 +37550,7 @@ ] ], [ - 18387, + 19081, [ { "DivMod": { @@ -36400,7 +37576,7 @@ ] ], [ - 18397, + 19091, [ { "DivMod": { @@ -36426,7 +37602,7 @@ ] ], [ - 18408, + 19102, [ { "DivMod": { @@ -36452,7 +37628,7 @@ ] ], [ - 18417, + 19111, [ { "WideMul128": { @@ -36481,7 +37657,7 @@ ] ], [ - 18419, + 19113, [ { "DivMod": { @@ -36507,7 +37683,7 @@ ] ], [ - 18429, + 19123, [ { "DivMod": { @@ -36533,7 +37709,7 @@ ] ], [ - 18440, + 19134, [ { "DivMod": { @@ -36559,7 +37735,7 @@ ] ], [ - 18450, + 19144, [ { "TestLessThan": { @@ -36581,7 +37757,7 @@ ] ], [ - 18472, + 19166, [ { "WideMul128": { @@ -36610,7 +37786,7 @@ ] ], [ - 18474, + 19168, [ { "DivMod": { @@ -36636,7 +37812,7 @@ ] ], [ - 18484, + 19178, [ { "DivMod": { @@ -36662,7 +37838,7 @@ ] ], [ - 18495, + 19189, [ { "DivMod": { @@ -36688,7 +37864,7 @@ ] ], [ - 18505, + 19199, [ { "TestLessThan": { @@ -36710,7 +37886,7 @@ ] ], [ - 18528, + 19222, [ { "TestLessThan": { @@ -36732,7 +37908,7 @@ ] ], [ - 18550, + 19244, [ { "WideMul128": { @@ -36761,7 +37937,7 @@ ] ], [ - 18552, + 19246, [ { "DivMod": { @@ -36787,7 +37963,7 @@ ] ], [ - 18562, + 19256, [ { "DivMod": { @@ -36813,7 +37989,7 @@ ] ], [ - 18573, + 19267, [ { "DivMod": { @@ -36839,7 +38015,7 @@ ] ], [ - 18583, + 19277, [ { "TestLessThan": { @@ -36861,7 +38037,7 @@ ] ], [ - 18607, + 19301, [ { "TestLessThan": { @@ -36883,7 +38059,7 @@ ] ], [ - 18632, + 19326, [ { "TestLessThan": { @@ -36905,7 +38081,7 @@ ] ], [ - 18656, + 19350, [ { "TestLessThan": { @@ -36927,7 +38103,7 @@ ] ], [ - 18774, + 19468, [ { "AllocSegment": { @@ -36940,7 +38116,7 @@ ] ], [ - 18797, + 19491, [ { "TestLessThanOrEqual": { @@ -36965,7 +38141,7 @@ ] ], [ - 18872, + 19566, [ { "AllocSegment": { @@ -36978,7 +38154,7 @@ ] ], [ - 18927, + 19621, [ { "DivMod": { @@ -37007,7 +38183,7 @@ ] ], [ - 18933, + 19627, [ { "TestLessThan": { @@ -37029,7 +38205,7 @@ ] ], [ - 18946, + 19640, [ { "TestLessThan": { @@ -37051,7 +38227,7 @@ ] ], [ - 18956, + 19650, [ { "TestLessThan": { @@ -37073,7 +38249,7 @@ ] ], [ - 19004, + 19698, [ { "DivMod": { @@ -37102,7 +38278,7 @@ ] ], [ - 19010, + 19704, [ { "TestLessThan": { @@ -37124,7 +38300,7 @@ ] ], [ - 19026, + 19720, [ { "TestLessThan": { @@ -37146,7 +38322,7 @@ ] ], [ - 19036, + 19730, [ { "TestLessThan": { @@ -37168,7 +38344,7 @@ ] ], [ - 19059, + 19753, [ { "AllocSegment": { @@ -37181,7 +38357,7 @@ ] ], [ - 19073, + 19767, [ { "AllocSegment": { @@ -37194,7 +38370,7 @@ ] ], [ - 19092, + 19786, [ { "AllocSegment": { @@ -37207,7 +38383,7 @@ ] ], [ - 19106, + 19800, [ { "AllocSegment": { @@ -37224,14 +38400,14 @@ "EXTERNAL": [ { "selector": "0x1143aa89c8e3ebf8ed14df2a3606c1cd2dd513fac8040b0f8ab441f5c52fe4", - "offset": 4442, + "offset": 4714, "builtins": [ "range_check" ] }, { "selector": "0x3541591104188daef4379e06e92ecce09094a3b381da2e654eb041d00566d8", - "offset": 5972, + "offset": 6244, "builtins": [ "range_check", "range_check96" @@ -37239,35 +38415,35 @@ }, { "selector": "0x3c118a68e16e12e97ed25cb4901c12f4d3162818669cc44c391d8049924c14", - "offset": 1687, + "offset": 1959, "builtins": [ "range_check" ] }, { "selector": "0x5562b3e932b4d139366854d5a2e578382e6a3b6572ac9943d55e7efbe43d00", - "offset": 3844, + "offset": 4116, "builtins": [ "range_check" ] }, { "selector": "0x600c98a299d72ef1e09a2e1503206fbc76081233172c65f7e2438ef0069d8d", - "offset": 4581, + "offset": 4853, "builtins": [ "range_check" ] }, { "selector": "0x62c83572d28cb834a3de3c1e94977a4191469a4a8c26d1d7bc55305e640ed5", - "offset": 4025, + "offset": 4297, "builtins": [ "range_check" ] }, { "selector": "0x679c22735055a10db4f275395763a3752a1e3a3043c192299ab6b574fba8d6", - "offset": 5427, + "offset": 5699, "builtins": [ "range_check", "ec_op" @@ -37275,7 +38451,7 @@ }, { "selector": "0x7772be8b80a8a33dc6c1f9a6ab820c02e537c73e859de67f288c70f92571bb", - "offset": 5072, + "offset": 5344, "builtins": [ "pedersen", "range_check", @@ -37291,21 +38467,21 @@ }, { "selector": "0xe7510edcf6e9f1b70f7bd1f488767b50f0363422f3c563160ab77adf62467b", - "offset": 2568, + "offset": 2840, "builtins": [ "range_check" ] }, { "selector": "0xf818e4530ec36b83dfe702489b4df537308c3b798b0cc120e32c2056d68b7d", - "offset": 3419, + "offset": 3691, "builtins": [ "range_check" ] }, { "selector": "0x10d2fede95e3ec06a875a67219425c27c5bd734d57f1b221d729a2337b6b556", - "offset": 2967, + "offset": 3239, "builtins": [ "range_check", "segment_arena" @@ -37313,28 +38489,28 @@ }, { "selector": "0x12ead94ae9d3f9d2bdb6b847cf255f1f398193a1f88884a0ae8e18f24a037b6", - "offset": 5688, + "offset": 5960, "builtins": [ "range_check" ] }, { "selector": "0x14dae1999ae9ab799bc72def6dc6e90890cf8ac0d64525021b7e71d05cb13e8", - "offset": 1173, + "offset": 1445, "builtins": [ "range_check" ] }, { "selector": "0x169f135eddda5ab51886052d777a57f2ea9c162d713691b5e04a6d4ed71d47f", - "offset": 3078, + "offset": 3350, "builtins": [ "range_check" ] }, { "selector": "0x1ae1a515cf2d214b29bdf63a79ee2d490efd4dd1acc99d383a8e549c3cecb5d", - "offset": 5538, + "offset": 5810, "builtins": [ "pedersen", "range_check" @@ -37342,14 +38518,14 @@ }, { "selector": "0x1e4089d1f1349077b1970f9937c904e27c4582b49a60b6078946dba95bc3c08", - "offset": 1002, + "offset": 1274, "builtins": [ "range_check" ] }, { "selector": "0x23039bef544cff56442d9f61ae9b13cf9e36fcce009102c5b678aac93f37b36", - "offset": 1509, + "offset": 1781, "builtins": [ "range_check" ] @@ -37361,30 +38537,37 @@ "range_check" ] }, + { + "selector": "0x298e03955860424b6a946506da72353a645f653dc1879f6b55fd756f3d20a59", + "offset": 712, + "builtins": [ + "range_check" + ] + }, { "selector": "0x2d7cf5d5a324a320f9f37804b1615a533fde487400b41af80f13f7ac5581325", - "offset": 2742, + "offset": 3014, "builtins": [ "range_check" ] }, { "selector": "0x30f842021fbf02caf80d09a113997c1e00a32870eee0c6136bed27acb348bea", - "offset": 5220, + "offset": 5492, "builtins": [ "range_check" ] }, { "selector": "0x31401f504973a5e8e1bb41e9c592519e3aa0b8cf6bbfb9c91b532aab8db54b0", - "offset": 712, + "offset": 6367, "builtins": [ "range_check" ] }, { "selector": "0x317eb442b72a9fae758d4fb26830ed0d9f31c8e7da4dbff4e8c59ea6a158e7f", - "offset": 4848, + "offset": 5120, "builtins": [ "pedersen", "range_check" @@ -37392,28 +38575,28 @@ }, { "selector": "0x32564d7e0fe091d49b4c20f4632191e4ed6986bf993849879abfef9465def25", - "offset": 4210, + "offset": 4482, "builtins": [ "range_check" ] }, { "selector": "0x3604cea1cdb094a73a31144f14a3e5861613c008e1e879939ebc4827d10cd50", - "offset": 1976, + "offset": 2248, "builtins": [ "range_check" ] }, { "selector": "0x382be990ca34815134e64a9ac28f41a907c62e5ad10547f97174362ab94dc89", - "offset": 3523, + "offset": 3795, "builtins": [ "range_check" ] }, { "selector": "0x38be5d5f7bf135b52888ba3e440a457d11107aca3f6542e574b016bf3f074d8", - "offset": 3627, + "offset": 3899, "builtins": [ "range_check", "bitwise" @@ -37421,7 +38604,7 @@ }, { "selector": "0x3a6a8bae4c51d5959683ae246347ffdd96aa5b2bfa68cc8c3a6a7c2ed0be331", - "offset": 2267, + "offset": 2539, "builtins": [ "range_check" ] @@ -37435,7 +38618,7 @@ }, { "selector": "0x3d3da80997f8be5d16e9ae7ee6a4b5f7191d60765a1a6c219ab74269c85cf97", - "offset": 5844, + "offset": 6116, "builtins": [ "range_check", "range_check96", @@ -37445,14 +38628,14 @@ }, { "selector": "0x3d95049b565ec2d4197a55108ef03996381d31c84acf392a0a42b28163d69d1", - "offset": 3740, + "offset": 4012, "builtins": [ "range_check" ] }, { "selector": "0x3eb640b15f75fcc06d43182cdb94ed38c8e71755d5fb57c16dd673b466db1d4", - "offset": 4303, + "offset": 4575, "builtins": [ "range_check" ] @@ -37461,14 +38644,14 @@ "L1_HANDLER": [ { "selector": "0x205500a208d0d49d79197fea83cc3f5fde99ac2e1909ae0a5d9f394c0c52ed0", - "offset": 6256, + "offset": 6818, "builtins": [ "range_check" ] }, { "selector": "0x39edbbb129ad752107a94d40c3873cae369a46fd2fc578d075679aa67e85d12", - "offset": 6095, + "offset": 6657, "builtins": [ "range_check" ] @@ -37477,7 +38660,7 @@ "CONSTRUCTOR": [ { "selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194", - "offset": 6506, + "offset": 7068, "builtins": [ "range_check" ] diff --git a/crates/blockifier/feature_contracts/cairo1/test_contract.cairo b/crates/blockifier/feature_contracts/cairo1/test_contract.cairo index 5ca7fa376be..d87a76efda4 100644 --- a/crates/blockifier/feature_contracts/cairo1/test_contract.cairo +++ b/crates/blockifier/feature_contracts/cairo1/test_contract.cairo @@ -71,31 +71,34 @@ mod TestContract { .span() } - #[external(v0)] - fn test_call_contract_revert( - ref self: ContractState, - contract_address: ContractAddress, - entry_point_selector: felt252, - calldata: Array:: - ) { - match syscalls::call_contract_syscall( - contract_address, entry_point_selector, calldata.span()) - { - Result::Ok(_) => panic!("Expected revert"), - Result::Err(errors) => { - let mut error_span = errors.span(); - assert( - *error_span.pop_back().unwrap() == 'ENTRYPOINT_FAILED', - 'Unexpected error', - ); - }, - }; - // TODO(Yoni, 1/12/2024): test replace class once get_class_hash_at syscall is supported. - assert(self.my_storage_var.read() == 0, 'values should not change.'); + fn test_call_two_contracts( + self: @ContractState, + contract_address_0: ContractAddress, + entry_point_selector_0: felt252, + calldata_0: Array::, + contract_address_1: ContractAddress, + entry_point_selector_1: felt252, + calldata_1: Array::, + ) -> Span:: { + let res_0 = syscalls::call_contract_syscall( + contract_address_0, + entry_point_selector_0, + calldata_0.span(), + ) + .unwrap_syscall(); + let res_1 = syscalls::call_contract_syscall( + contract_address_1, + entry_point_selector_1, + calldata_1.span(), + ) + .unwrap_syscall(); + let mut res: Array:: = Default::default(); + res.append_span(res_0.snapshot.span()); + res.append_span(res_1.snapshot.span()); + res.span() } - #[external(v0)] fn test_revert_helper(ref self: ContractState, class_hash: ClassHash) { let dummy_span = array![0].span(); @@ -605,4 +608,27 @@ mod TestContract { let in1 = CircuitElement::> {}; (in1,).new_inputs().next([3, 0, 0, 0]); } + + #[external(v0)] + fn test_call_contract_revert( + ref self: ContractState, + contract_address: ContractAddress, + entry_point_selector: felt252, + calldata: Array:: + ) { + match syscalls::call_contract_syscall( + contract_address, entry_point_selector, calldata.span()) + { + Result::Ok(_) => panic!("Expected revert"), + Result::Err(errors) => { + let mut error_span = errors.span(); + assert( + *error_span.pop_back().unwrap() == 'ENTRYPOINT_FAILED', + 'Unexpected error', + ); + }, + }; + // TODO(Yoni, 1/12/2024): test replace class once get_class_hash_at syscall is supported. + assert(self.my_storage_var.read() == 0, 'values should not change.'); + } } diff --git a/crates/blockifier/src/execution/stack_trace_test.rs b/crates/blockifier/src/execution/stack_trace_test.rs index c5c743120ec..0b9cca54c23 100644 --- a/crates/blockifier/src/execution/stack_trace_test.rs +++ b/crates/blockifier/src/execution/stack_trace_test.rs @@ -114,9 +114,9 @@ Unknown location (pc=0:{entry_point_location}) 2: Error in the called contract (contract address: {test_contract_address_2_felt:#064x}, class \ hash: {test_contract_hash:#064x}, selector: {inner_entry_point_selector_felt:#064x}): Error message: You shall not pass! -Error at pc=0:1215: +Error at pc=0:1290: Cairo traceback (most recent call last): -Unknown location (pc=0:1219) +Unknown location (pc=0:1294) An ASSERT_EQ instruction failed: 1 != 0. " @@ -202,9 +202,9 @@ Unknown location (pc=0:{entry_point_location}) 2: Error in the called contract (contract address: {test_contract_address_2_felt:#064x}, class \ hash: {test_contract_hash:#064x}, selector: {inner_entry_point_selector_felt:#064x}): Error message: You shall not pass! -Error at pc=0:1215: +Error at pc=0:1290: Cairo traceback (most recent call last): -Unknown location (pc=0:1219) +Unknown location (pc=0:1294) An ASSERT_EQ instruction failed: 1 != 0. " @@ -230,8 +230,8 @@ Execution failed. Failure reason: (0x6661696c ('fail'), 0x454e545259504f494e545f } #[rstest] -#[case(CairoVersion::Cairo0, "invoke_call_chain", "Couldn't compute operand op0. Unknown value for memory cell 1:37", (1112_u16, 1158_u16))] -#[case(CairoVersion::Cairo0, "fail", "An ASSERT_EQ instruction failed: 1 != 0.", (1215_u16, 1166_u16))] +#[case(CairoVersion::Cairo0, "invoke_call_chain", "Couldn't compute operand op0. Unknown value for memory cell 1:37", (1187_u16, 1233_u16))] +#[case(CairoVersion::Cairo0, "fail", "An ASSERT_EQ instruction failed: 1 != 0.", (1290_u16, 1241_u16))] #[case(CairoVersion::Cairo1, "invoke_call_chain", "0x4469766973696f6e2062792030 ('Division by 0')", (0_u16, 0_u16))] #[case(CairoVersion::Cairo1, "fail", "0x6661696c ('fail')", (0_u16, 0_u16))] fn test_trace_callchain_ends_with_regular_call( @@ -345,10 +345,10 @@ Execution failed. Failure reason: ({expected_error}, 0x454e545259504f494e545f464 } #[rstest] -#[case(CairoVersion::Cairo0, "invoke_call_chain", "Couldn't compute operand op0. Unknown value for memory cell 1:23", 1_u8, 0_u8, (37_u16, 1124_u16, 1112_u16, 1197_u16))] -#[case(CairoVersion::Cairo0, "invoke_call_chain", "Couldn't compute operand op0. Unknown value for memory cell 1:23", 1_u8, 1_u8, (49_u16, 1142_u16, 1112_u16, 1197_u16))] -#[case(CairoVersion::Cairo0, "fail", "An ASSERT_EQ instruction failed: 1 != 0.", 0_u8, 0_u8, (37_u16, 1124_u16, 1215_u16, 1219_u16))] -#[case(CairoVersion::Cairo0, "fail", "An ASSERT_EQ instruction failed: 1 != 0.", 0_u8, 1_u8, (49_u16, 1142_u16, 1215_u16, 1219_u16))] +#[case(CairoVersion::Cairo0, "invoke_call_chain", "Couldn't compute operand op0. Unknown value for memory cell 1:23", 1_u8, 0_u8, (37_u16, 1199_u16, 1187_u16, 1272_u16))] +#[case(CairoVersion::Cairo0, "invoke_call_chain", "Couldn't compute operand op0. Unknown value for memory cell 1:23", 1_u8, 1_u8, (49_u16, 1217_u16, 1187_u16, 1272_u16))] +#[case(CairoVersion::Cairo0, "fail", "An ASSERT_EQ instruction failed: 1 != 0.", 0_u8, 0_u8, (37_u16, 1199_u16, 1290_u16, 1294_u16))] +#[case(CairoVersion::Cairo0, "fail", "An ASSERT_EQ instruction failed: 1 != 0.", 0_u8, 1_u8, (49_u16, 1217_u16, 1290_u16, 1294_u16))] #[case(CairoVersion::Cairo1, "invoke_call_chain", "0x4469766973696f6e2062792030 ('Division by 0')", 1_u8, 0_u8, (9631_u16, 9631_u16, 0_u16, 0_u16))] #[case(CairoVersion::Cairo1, "invoke_call_chain", "0x4469766973696f6e2062792030 ('Division by 0')", 1_u8, 1_u8, (9631_u16, 9700_u16, 0_u16, 0_u16))] #[case(CairoVersion::Cairo1, "fail", "0x6661696c ('fail')", 0_u8, 0_u8, (9631_u16, 9631_u16, 0_u16, 0_u16))] diff --git a/crates/blockifier/src/execution/syscalls/syscall_tests/call_contract.rs b/crates/blockifier/src/execution/syscalls/syscall_tests/call_contract.rs index 78f8236fb2f..3a519964faa 100644 --- a/crates/blockifier/src/execution/syscalls/syscall_tests/call_contract.rs +++ b/crates/blockifier/src/execution/syscalls/syscall_tests/call_contract.rs @@ -1,13 +1,18 @@ use core::panic; +use std::sync::Arc; +use itertools::Itertools; use pretty_assertions::assert_eq; +use rstest::rstest; use starknet_api::felt; +use starknet_api::transaction::Calldata; use test_case::test_case; use super::constants::REQUIRED_GAS_CALL_CONTRACT_TEST; use crate::abi::abi_utils::selector_from_name; use crate::context::ChainInfo; use crate::execution::call_info::{CallExecution, Retdata}; +use crate::execution::contract_class::TrackedResource; use crate::execution::entry_point::CallEntryPoint; use crate::execution::execution_utils::format_panic_data; use crate::retdata; @@ -90,3 +95,99 @@ fn test_call_contract( } ); } + +/// Cairo0 / Cairo1 calls to Cairo0 / Cairo1. +#[rstest] +fn test_track_resources( + #[values(CairoVersion::Cairo0, CairoVersion::Cairo1)] outer_version: CairoVersion, + #[values(CairoVersion::Cairo0, CairoVersion::Cairo1)] inner_version: CairoVersion, +) { + let outer_contract = FeatureContract::TestContract(outer_version); + let inner_contract = FeatureContract::TestContract(inner_version); + let chain_info = &ChainInfo::create_for_testing(); + let mut state = test_state(chain_info, BALANCE, &[(outer_contract, 1), (inner_contract, 1)]); + + let outer_entry_point_selector = selector_from_name("test_call_contract"); + let calldata = create_calldata( + inner_contract.get_instance_address(0), + "test_storage_read_write", + &[ + felt!(405_u16), // Calldata: address. + felt!(48_u8), // Calldata: value. + ], + ); + let entry_point_call = CallEntryPoint { + entry_point_selector: outer_entry_point_selector, + calldata, + ..trivial_external_entry_point_new(outer_contract) + }; + + let execution = entry_point_call.execute_directly(&mut state).unwrap(); + let expected_outer_resource = match outer_version { + CairoVersion::Cairo0 => TrackedResource::CairoSteps, + CairoVersion::Cairo1 => TrackedResource::SierraGas, + }; + assert_eq!(execution.tracked_resource, expected_outer_resource); + + let expected_inner_resource = match (outer_version, inner_version) { + (CairoVersion::Cairo1, CairoVersion::Cairo1) => TrackedResource::SierraGas, + _ => TrackedResource::CairoSteps, + }; + assert_eq!(execution.inner_calls.first().unwrap().tracked_resource, expected_inner_resource); +} + +/// Cairo1 contract (root) calls: +/// 1) Cairo0 contract (first) that calls Cairo1 (nested) contract. +/// 2) Cairo1 contract (second). +#[test] +fn test_track_resources_nested() { + let cairo_0_contract = FeatureContract::TestContract(CairoVersion::Cairo0); + let cairo_1_contract = FeatureContract::TestContract(CairoVersion::Cairo1); + let chain_info = &ChainInfo::create_for_testing(); + let mut state = + test_state(chain_info, BALANCE, &[(cairo_1_contract, 1), (cairo_0_contract, 1)]); + + let first_calldata = create_calldata( + cairo_0_contract.get_instance_address(0), + "test_call_contract", + &[ + cairo_1_contract.get_instance_address(0).into(), + selector_from_name("test_storage_read_write").0, + felt!(2_u8), // Calldata length + felt!(405_u16), // Calldata: address. + felt!(48_u8), // Calldata: value. + ], + ); + let second_calldata = create_calldata( + cairo_1_contract.get_instance_address(0), + "test_storage_read_write", + &[ + felt!(406_u16), // Calldata: address. + felt!(49_u8), // Calldata: value. + ], + ); + + let concated_calldata_felts = [first_calldata.0, second_calldata.0] + .into_iter() + .map(|calldata_felts| calldata_felts.iter().copied().collect_vec()) + .concat(); + let concated_calldata = Calldata(Arc::new(concated_calldata_felts)); + let call_contract_selector = selector_from_name("test_call_two_contracts"); + let entry_point_call = CallEntryPoint { + entry_point_selector: call_contract_selector, + calldata: concated_calldata, + ..trivial_external_entry_point_new(cairo_1_contract) + }; + let execution = entry_point_call.execute_directly(&mut state).unwrap(); + + assert_eq!(execution.tracked_resource, TrackedResource::SierraGas); + let first_call_info = execution.inner_calls.first().unwrap(); + assert_eq!(first_call_info.tracked_resource, TrackedResource::CairoSteps); + assert_eq!( + first_call_info.inner_calls.first().unwrap().tracked_resource, + TrackedResource::CairoSteps + ); + + let second_inner_call_info = execution.inner_calls.get(1).unwrap(); + assert_eq!(second_inner_call_info.tracked_resource, TrackedResource::SierraGas); +} From 4171ff84ad9c7fb3d8d16962dfb9335adeb6dd5b Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 11:03:14 +0300 Subject: [PATCH 18/57] feat(ci): split some main CI jobs into PR-only workflow (#1260) Signed-off-by: Dori Medini --- .github/workflows/main.yml | 51 --------------------------- .github/workflows/main_pr.yml | 66 +++++++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+), 51 deletions(-) create mode 100644 .github/workflows/main_pr.yml diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index a87db9c686e..cd9c7ed1465 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -22,29 +22,6 @@ concurrency: cancel-in-progress: ${{ github.event_name == 'pull_request' }} jobs: - commitlint: - runs-on: starkware-ubuntu-latest-small - steps: - - uses: actions/checkout@v4 - with: - fetch-depth: 0 - - - name: Install commitlint - run: npm install --global @commitlint/cli @commitlint/config-conventional - - - name: Validate PR commits with commitlint - if: github.event_name == 'pull_request' && !(contains(github.event.pull_request.title, 'merge-main') || contains(github.event.pull_request.title, 'merge main')) - env: - BASE_SHA: ${{ github.event.pull_request.base.sha }} - HEAD_SHA: ${{ github.event.pull_request.head.sha }} - run: commitlint --from "$BASE_SHA" --to "$HEAD_SHA" --verbose - - - name: Validate PR title with commitlint - if: github.event_name != 'merge_group' && github.event_name != 'push' && !(contains(github.event.pull_request.title, 'merge-main') || contains(github.event.pull_request.title, 'merge main')) - env: - TITLE: ${{ github.event.pull_request.title }} - run: echo "$TITLE" | commitlint --verbose - code_style: runs-on: starkware-ubuntu-20-04-medium steps: @@ -85,7 +62,6 @@ jobs: - name: Run Machete (detect unused dependencies) uses: bnjbvr/cargo-machete@main - run-workspace-tests: runs-on: starkware-ubuntu-latest-medium steps: @@ -130,33 +106,6 @@ jobs: env: SEED: 0 - merge-gatekeeper: - runs-on: starkware-ubuntu-latest-small - # Restrict permissions of the GITHUB_TOKEN. - # Docs: https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs - permissions: - checks: read - statuses: read - steps: - - name: Run Merge Gatekeeper on pull request - if: github.event_name == 'pull_request' - uses: upsidr/merge-gatekeeper@v1 - with: - token: ${{ secrets.GITHUB_TOKEN }} - timeout: 1500 - interval: 30 - ignored: "code-review/reviewable" - - - name: Run Merge Gatekeeper on Merge Queue || push - if: github.event_name == 'merge_group' || github.event_name == 'push' - uses: upsidr/merge-gatekeeper@v1 - with: - token: ${{ secrets.GITHUB_TOKEN }} - ref: ${{github.ref}} - timeout: 1500 - interval: 30 - ignored: "code-review/reviewable" - codecov: runs-on: starkware-ubuntu-latest-medium steps: diff --git a/.github/workflows/main_pr.yml b/.github/workflows/main_pr.yml new file mode 100644 index 00000000000..a3d5cfe0946 --- /dev/null +++ b/.github/workflows/main_pr.yml @@ -0,0 +1,66 @@ +name: Main-CI-PR-Flow + +on: + pull_request: + types: + - opened + - reopened + - synchronize + - auto_merge_enabled + - edited + +# On PR events, cancel existing CI runs on this same PR for this workflow. +concurrency: + group: ${{ github.workflow }}-${{ github.ref }}-${{ github.job }} + cancel-in-progress: ${{ github.event_name == 'pull_request' }} + +jobs: + commitlint: + runs-on: starkware-ubuntu-latest-small + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Install commitlint + run: npm install --global @commitlint/cli @commitlint/config-conventional + + - name: Validate PR commits with commitlint + if: github.event_name == 'pull_request' && !(contains(github.event.pull_request.title, 'merge-main') || contains(github.event.pull_request.title, 'merge main')) + env: + BASE_SHA: ${{ github.event.pull_request.base.sha }} + HEAD_SHA: ${{ github.event.pull_request.head.sha }} + run: commitlint --from "$BASE_SHA" --to "$HEAD_SHA" --verbose + + - name: Validate PR title with commitlint + if: github.event_name != 'merge_group' && github.event_name != 'push' && !(contains(github.event.pull_request.title, 'merge-main') || contains(github.event.pull_request.title, 'merge main')) + env: + TITLE: ${{ github.event.pull_request.title }} + run: echo "$TITLE" | commitlint --verbose + + merge-gatekeeper: + runs-on: starkware-ubuntu-latest-small + # Restrict permissions of the GITHUB_TOKEN. + # Docs: https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs + permissions: + checks: read + statuses: read + steps: + - name: Run Merge Gatekeeper on pull request + if: github.event_name == 'pull_request' + uses: upsidr/merge-gatekeeper@v1 + with: + token: ${{ secrets.GITHUB_TOKEN }} + timeout: 1500 + interval: 30 + ignored: "code-review/reviewable" + + - name: Run Merge Gatekeeper on Merge Queue || push + if: github.event_name == 'merge_group' || github.event_name == 'push' + uses: upsidr/merge-gatekeeper@v1 + with: + token: ${{ secrets.GITHUB_TOKEN }} + ref: ${{github.ref}} + timeout: 1500 + interval: 30 + ignored: "code-review/reviewable" From 452e4a527dc833dc28ee480e85fcac8509dfe17f Mon Sep 17 00:00:00 2001 From: Elin Date: Wed, 9 Oct 2024 11:13:05 +0300 Subject: [PATCH 19/57] feat(mempool): add account_txs API to TransactionPool (#1257) --- crates/mempool/src/transaction_pool.rs | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/crates/mempool/src/transaction_pool.rs b/crates/mempool/src/transaction_pool.rs index 2bdcba7bafa..082df4eb287 100644 --- a/crates/mempool/src/transaction_pool.rs +++ b/crates/mempool/src/transaction_pool.rs @@ -83,6 +83,13 @@ impl TransactionPool { } } + pub fn _account_txs_sorted_by_nonce( + &self, + address: ContractAddress, + ) -> impl Iterator { + self.txs_by_account._account_txs_sorted_by_nonce(address) + } + pub fn _get_by_tx_hash(&self, tx_hash: TransactionHash) -> MempoolResult<&Transaction> { self.tx_pool.get(&tx_hash).ok_or(MempoolError::TransactionNotFound { tx_hash }) } @@ -136,6 +143,13 @@ impl AccountTransactionIndex { self.0.get(&address)?.get(&nonce) } + fn _account_txs_sorted_by_nonce( + &self, + address: ContractAddress, + ) -> impl Iterator { + self.0.get(&address).into_iter().flat_map(|nonce_to_tx_ref| nonce_to_tx_ref.values()) + } + fn remove_up_to_nonce( &mut self, address: ContractAddress, From 9f7dbdf20df595c3322d4eb9f9baeaed5d962764 Mon Sep 17 00:00:00 2001 From: Yair Bakalchuk Date: Wed, 25 Sep 2024 13:14:47 +0300 Subject: [PATCH 20/57] feat(batcher): start height --- crates/batcher/src/batcher.rs | 58 +++++++++++++-- crates/batcher/src/communication.rs | 3 + crates/batcher/src/proposal_manager.rs | 67 +++++++++++++++-- crates/batcher/src/proposal_manager_test.rs | 81 +++++++++++++++++++++ crates/batcher_types/src/errors.rs | 20 ++++- 5 files changed, 214 insertions(+), 15 deletions(-) diff --git a/crates/batcher/src/batcher.rs b/crates/batcher/src/batcher.rs index 62c743a2aea..79b39e63ae9 100644 --- a/crates/batcher/src/batcher.rs +++ b/crates/batcher/src/batcher.rs @@ -3,11 +3,13 @@ use std::sync::Arc; use blockifier::blockifier::block::BlockNumberHashPair; #[cfg(test)] use mockall::automock; +use papyrus_storage::state::StateStorageReader; use starknet_api::block::BlockNumber; -use starknet_batcher_types::batcher_types::BuildProposalInput; +use starknet_batcher_types::batcher_types::{BatcherResult, BuildProposalInput, StartHeightInput}; use starknet_batcher_types::errors::BatcherError; use starknet_mempool_infra::component_definitions::ComponentStarter; use starknet_mempool_types::communication::SharedMempoolClient; +use tracing::error; use crate::block_builder::{BlockBuilderFactoryTrait, BlockBuilderResult, BlockBuilderTrait}; use crate::config::BatcherConfig; @@ -42,20 +44,47 @@ impl Batcher { Self { config: config.clone(), mempool_client: mempool_client.clone(), - storage, + storage: storage.clone(), proposal_manager: ProposalManager::new( config.proposal_manager.clone(), mempool_client.clone(), // TODO(Yael 7/10/2024) : Pass the real BlockBuilderFactory Arc::new(DummyBlockBuilderFactory {}), + storage, ), } } + pub fn start_height(&mut self, input: StartHeightInput) -> BatcherResult<()> { + self.proposal_manager.start_height(input.height).map_err(|err| match err { + ProposalManagerError::AlreadyWorkingOnHeight { active_height, new_height } => { + BatcherError::AlreadyWorkingOnHeight { active_height, new_height } + } + ProposalManagerError::HeightAlreadyPassed { storage_height, requested_height } => { + BatcherError::HeightAlreadyPassed { storage_height, requested_height } + } + ProposalManagerError::StorageError(err) => { + error!("{}", err); + BatcherError::InternalError + } + ProposalManagerError::StorageNotSynced { storage_height, requested_height } => { + error!("{}", err); + BatcherError::StorageNotSynced { storage_height, requested_height } + } + ProposalManagerError::AlreadyGeneratingProposal { .. } + | ProposalManagerError::MempoolError { .. } + | ProposalManagerError::NoActiveHeight + | ProposalManagerError::ProposalAlreadyExists { .. } + | ProposalManagerError::BlockBuilderError(..) => { + unreachable!("Shouldn't happen here: {}", err) + } + }) + } + pub async fn build_proposal( &mut self, build_proposal_input: BuildProposalInput, - ) -> Result<(), BatcherError> { + ) -> BatcherResult<()> { // TODO: Save the receiver as a stream for later use. let (content_sender, _content_receiver) = tokio::sync::mpsc::channel(self.config.outstream_content_buffer_size); @@ -80,10 +109,20 @@ impl Batcher { new_proposal_id, }, ProposalManagerError::BlockBuilderError(..) => BatcherError::InternalError, - ProposalManagerError::MempoolError(..) => BatcherError::InternalError, ProposalManagerError::ProposalAlreadyExists { proposal_id } => { BatcherError::ProposalAlreadyExists { proposal_id } } + ProposalManagerError::MempoolError(..) => { + error!("MempoolError: {}", err); + BatcherError::InternalError + } + ProposalManagerError::NoActiveHeight => BatcherError::NoActiveHeight, + ProposalManagerError::AlreadyWorkingOnHeight { .. } + | ProposalManagerError::HeightAlreadyPassed { .. } + | ProposalManagerError::StorageError(..) + | ProposalManagerError::StorageNotSynced { .. } => { + unreachable!("Shouldn't happen here: {}", err) + } })?; Ok(()) } @@ -96,7 +135,14 @@ pub fn create_batcher(config: BatcherConfig, mempool_client: SharedMempoolClient } #[cfg_attr(test, automock)] -pub trait BatcherStorageReaderTrait: Send + Sync {} +pub trait BatcherStorageReaderTrait: Send + Sync { + fn height(&self) -> papyrus_storage::StorageResult; +} + +impl BatcherStorageReaderTrait for papyrus_storage::StorageReader { + fn height(&self) -> papyrus_storage::StorageResult { + self.begin_ro_txn()?.get_state_marker() + } +} -impl BatcherStorageReaderTrait for papyrus_storage::StorageReader {} impl ComponentStarter for Batcher {} diff --git a/crates/batcher/src/communication.rs b/crates/batcher/src/communication.rs index 4878b923572..86752641b9d 100644 --- a/crates/batcher/src/communication.rs +++ b/crates/batcher/src/communication.rs @@ -26,6 +26,9 @@ impl ComponentRequestHandler for Batcher { BatcherRequest::BuildProposal(input) => { BatcherResponse::BuildProposal(self.build_proposal(input).await) } + BatcherRequest::StartHeight(input) => { + BatcherResponse::StartHeight(self.start_height(input)) + } _ => unimplemented!(), } } diff --git a/crates/batcher/src/proposal_manager.rs b/crates/batcher/src/proposal_manager.rs index 8ecf2435f22..2522cc12faf 100644 --- a/crates/batcher/src/proposal_manager.rs +++ b/crates/batcher/src/proposal_manager.rs @@ -15,6 +15,7 @@ use tokio::sync::Mutex; use tokio_stream::wrappers::ReceiverStream; use tracing::{debug, error, info, instrument, trace, Instrument}; +use crate::batcher::BatcherStorageReaderTrait; use crate::block_builder::{BlockBuilderError, BlockBuilderFactoryTrait, BlockBuilderTrait}; #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)] @@ -60,15 +61,31 @@ pub enum ProposalManagerError { current_generating_proposal_id: ProposalId, new_proposal_id: ProposalId, }, + #[error("Can't start new height {new_height} while working on height {active_height}.")] + AlreadyWorkingOnHeight { active_height: BlockNumber, new_height: BlockNumber }, + #[error( + "Requested height {requested_height} is lower than the current storage height \ + {storage_height}." + )] + HeightAlreadyPassed { storage_height: BlockNumber, requested_height: BlockNumber }, #[error(transparent)] BlockBuilderError(#[from] BlockBuilderError), #[error(transparent)] MempoolError(#[from] MempoolClientError), + #[error("No active height to work on.")] + NoActiveHeight, #[error("Proposal with ID {proposal_id} already exists.")] ProposalAlreadyExists { proposal_id: ProposalId }, + #[error(transparent)] + StorageError(#[from] papyrus_storage::StorageError), + #[error( + "Storage is not synced. Storage height: {storage_height}, requested height: \ + {requested_height}." + )] + StorageNotSynced { storage_height: BlockNumber, requested_height: BlockNumber }, } -pub type ProposalsManagerResult = Result; +pub type ProposalManagerResult = Result; /// Main struct for handling block proposals. /// Taking care of: @@ -80,6 +97,8 @@ pub type ProposalsManagerResult = Result; pub(crate) struct ProposalManager { config: ProposalManagerConfig, mempool_client: SharedMempoolClient, + storage_reader: Arc, + active_height: Option, /// The block proposal that is currently being proposed, if any. /// At any given time, there can be only one proposal being actively executed (either proposed /// or validated). @@ -91,28 +110,59 @@ pub(crate) struct ProposalManager { proposals: Vec, } -type ActiveTaskHandle = tokio::task::JoinHandle>; +type ActiveTaskHandle = tokio::task::JoinHandle>; impl ProposalManager { pub fn new( config: ProposalManagerConfig, mempool_client: SharedMempoolClient, block_builder_factory: Arc, + storage_reader: Arc, ) -> Self { Self { config, mempool_client, + storage_reader, active_proposal: Arc::new(Mutex::new(None)), block_builder_factory, active_proposal_handle: None, + active_height: None, proposals: Vec::new(), } } + /// Starts working on the given height. + #[instrument(skip(self), err)] + pub fn start_height(&mut self, height: BlockNumber) -> ProposalManagerResult<()> { + // TODO: handle the case when `next_height==height && active_height height { + return Err(ProposalManagerError::HeightAlreadyPassed { + storage_height: next_height, + requested_height: height, + }); + } + self.active_height = Some(height); + Ok(()) + } + /// Starts a new block proposal generation task for the given proposal_id and height with /// transactions from the mempool. /// Requires output_content_sender for sending the generated transactions to the caller. - #[instrument(skip(self, output_content_sender), err)] + #[instrument(skip(self, output_content_sender), err, fields(self.active_height))] pub async fn build_block_proposal( &mut self, proposal_id: ProposalId, @@ -120,7 +170,10 @@ impl ProposalManager { deadline: tokio::time::Instant, // TODO: Should this be an unbounded channel? output_content_sender: tokio::sync::mpsc::Sender, - ) -> ProposalsManagerResult<()> { + ) -> ProposalManagerResult<()> { + if self.active_height.is_none() { + return Err(ProposalManagerError::NoActiveHeight); + } if self.proposals.contains(&proposal_id) { return Err(ProposalManagerError::ProposalAlreadyExists { proposal_id }); } @@ -152,7 +205,7 @@ impl ProposalManager { // Checks if there is already a proposal being generated, and if not, sets the given proposal_id // as the one being generated. - async fn set_active_proposal(&mut self, proposal_id: ProposalId) -> ProposalsManagerResult<()> { + async fn set_active_proposal(&mut self, proposal_id: ProposalId) -> ProposalManagerResult<()> { let mut lock = self.active_proposal.lock().await; if let Some(active_proposal) = *lock { @@ -170,7 +223,7 @@ impl ProposalManager { // A helper function for testing purposes (to be able to await the active proposal). // TODO: Consider making the tests a nested module to allow them to access private members. #[cfg(test)] - pub async fn await_active_proposal(&mut self) -> Option> { + pub async fn await_active_proposal(&mut self) -> Option> { match self.active_proposal_handle.take() { Some(handle) => Some(handle.await.unwrap()), None => None, @@ -189,7 +242,7 @@ struct BuildProposalTask { } impl BuildProposalTask { - async fn run(mut self) -> ProposalsManagerResult<()> { + async fn run(mut self) -> ProposalManagerResult<()> { // We convert the receiver to a stream and pass it to the block builder while using the // sender to feed the stream. let (mempool_tx_sender, mempool_tx_receiver) = diff --git a/crates/batcher/src/proposal_manager_test.rs b/crates/batcher/src/proposal_manager_test.rs index 4453f2290cf..083d9eb5444 100644 --- a/crates/batcher/src/proposal_manager_test.rs +++ b/crates/batcher/src/proposal_manager_test.rs @@ -8,6 +8,7 @@ use futures::FutureExt; #[cfg(test)] use mockall::automock; use rstest::{fixture, rstest}; +use starknet_api::block::BlockNumber; use starknet_api::executable_transaction::Transaction; use starknet_api::felt; use starknet_api::test_utils::invoke::{executable_invoke_tx, InvokeTxArgs}; @@ -17,6 +18,7 @@ use starknet_mempool_types::communication::MockMempoolClient; use tokio_stream::wrappers::ReceiverStream; use tokio_stream::StreamExt; +use crate::batcher::MockBatcherStorageReaderTrait; use crate::block_builder::{ BlockBuilderResult, BlockBuilderTrait, @@ -28,10 +30,13 @@ use crate::proposal_manager::{ ProposalManager, ProposalManagerConfig, ProposalManagerError, + ProposalManagerResult, }; pub type OutputTxStream = ReceiverStream; +const INITIAL_HEIGHT: BlockNumber = BlockNumber(3); + #[fixture] fn proposal_manager_config() -> ProposalManagerConfig { ProposalManagerConfig::default() @@ -58,6 +63,70 @@ fn output_streaming() -> (tokio::sync::mpsc::Sender, OutputTxStream (output_content_sender, stream) } +#[fixture] +fn storage_reader() -> MockBatcherStorageReaderTrait { + let mut storage = MockBatcherStorageReaderTrait::new(); + storage.expect_height().returning(|| Ok(INITIAL_HEIGHT)); + storage +} + +#[fixture] +fn proposal_manager( + proposal_manager_config: ProposalManagerConfig, + mempool_client: MockMempoolClient, + block_builder_factory: MockBlockBuilderFactoryTrait, + storage_reader: MockBatcherStorageReaderTrait, +) -> ProposalManager { + ProposalManager::new( + proposal_manager_config, + Arc::new(mempool_client), + Arc::new(block_builder_factory), + Arc::new(storage_reader), + ) +} + +#[rstest] +#[case::height_already_passed( + INITIAL_HEIGHT.prev().unwrap(), + ProposalManagerResult::Err(ProposalManagerError::HeightAlreadyPassed { + storage_height: INITIAL_HEIGHT, + requested_height: INITIAL_HEIGHT.prev().unwrap() + } +))] +#[case::happy( + INITIAL_HEIGHT, + ProposalManagerResult::Ok(()) +)] +#[case::storage_not_synced( + INITIAL_HEIGHT.unchecked_next(), + ProposalManagerResult::Err(ProposalManagerError::StorageNotSynced { + storage_height: INITIAL_HEIGHT, + requested_height: INITIAL_HEIGHT.unchecked_next() + } +))] +fn start_height( + mut proposal_manager: ProposalManager, + #[case] height: BlockNumber, + #[case] expected_result: ProposalManagerResult<()>, +) { + let result = proposal_manager.start_height(height); + // Unfortunatelly ProposalManagerError doesn't implement PartialEq. + assert_eq!(format!("{:?}", result), format!("{:?}", expected_result)); +} + +#[rstest] +#[tokio::test] +async fn proposal_generation_fails_without_start_height( + mut proposal_manager: ProposalManager, + output_streaming: (tokio::sync::mpsc::Sender, OutputTxStream), +) { + let (output_content_sender, _stream) = output_streaming; + let err = proposal_manager + .build_block_proposal(ProposalId(0), None, arbitrary_deadline(), output_content_sender) + .await; + assert_matches!(err, Err(ProposalManagerError::NoActiveHeight)); +} + #[rstest] #[tokio::test] async fn proposal_generation_success( @@ -65,6 +134,7 @@ async fn proposal_generation_success( mut block_builder_factory: MockBlockBuilderFactoryTrait, mut mempool_client: MockMempoolClient, output_streaming: (tokio::sync::mpsc::Sender, OutputTxStream), + storage_reader: MockBatcherStorageReaderTrait, ) { let n_txs = 2 * proposal_manager_config.max_txs_per_mempool_request; block_builder_factory @@ -85,8 +155,11 @@ async fn proposal_generation_success( proposal_manager_config.clone(), Arc::new(mempool_client), Arc::new(block_builder_factory), + Arc::new(storage_reader), ); + proposal_manager.start_height(INITIAL_HEIGHT).unwrap(); + let (output_content_sender, stream) = output_streaming; proposal_manager .build_block_proposal(ProposalId(0), None, arbitrary_deadline(), output_content_sender) @@ -104,6 +177,7 @@ async fn consecutive_proposal_generations_success( proposal_manager_config: ProposalManagerConfig, mut block_builder_factory: MockBlockBuilderFactoryTrait, mut mempool_client: MockMempoolClient, + storage_reader: MockBatcherStorageReaderTrait, ) { let n_txs = proposal_manager_config.max_txs_per_mempool_request; block_builder_factory @@ -119,8 +193,11 @@ async fn consecutive_proposal_generations_success( proposal_manager_config.clone(), Arc::new(mempool_client), Arc::new(block_builder_factory), + Arc::new(storage_reader), ); + proposal_manager.start_height(INITIAL_HEIGHT).unwrap(); + let (output_content_sender, stream) = output_streaming(); proposal_manager .build_block_proposal(ProposalId(0), None, arbitrary_deadline(), output_content_sender) @@ -150,6 +227,7 @@ async fn multiple_proposals_generation_fail( proposal_manager_config: ProposalManagerConfig, mut block_builder_factory: MockBlockBuilderFactoryTrait, mut mempool_client: MockMempoolClient, + storage_reader: MockBatcherStorageReaderTrait, ) { // The block builder will never stop. block_builder_factory @@ -163,8 +241,11 @@ async fn multiple_proposals_generation_fail( proposal_manager_config.clone(), Arc::new(mempool_client), Arc::new(block_builder_factory), + Arc::new(storage_reader), ); + proposal_manager.start_height(INITIAL_HEIGHT).unwrap(); + // A proposal that will never finish. let (output_content_sender, _stream) = output_streaming(); proposal_manager diff --git a/crates/batcher_types/src/errors.rs b/crates/batcher_types/src/errors.rs index b554d0c9873..3f3b60227a1 100644 --- a/crates/batcher_types/src/errors.rs +++ b/crates/batcher_types/src/errors.rs @@ -1,21 +1,37 @@ use chrono::prelude::*; use serde::{Deserialize, Serialize}; +use starknet_api::block::BlockNumber; use thiserror::Error; use crate::batcher_types::ProposalId; #[derive(Clone, Debug, Error, PartialEq, Eq, Serialize, Deserialize)] pub enum BatcherError { + #[error( + "Already working on height {active_height}, can't start working on height {new_height}." + )] + AlreadyWorkingOnHeight { active_height: BlockNumber, new_height: BlockNumber }, + #[error( + "Height {storage_height} already passed, can't start working on height {requested_height}." + )] + HeightAlreadyPassed { storage_height: BlockNumber, requested_height: BlockNumber }, #[error("Internal server error.")] InternalError, - #[error("Proposal with ID {proposal_id} already exists.")] - ProposalAlreadyExists { proposal_id: ProposalId }, + #[error("Attempt to start proposal with no active height.")] + NoActiveHeight, #[error( "There is already an active proposal {}, can't start proposal {}.", active_proposal_id, new_proposal_id )] ServerBusy { active_proposal_id: ProposalId, new_proposal_id: ProposalId }, + #[error("Proposal with ID {proposal_id} already exists.")] + ProposalAlreadyExists { proposal_id: ProposalId }, + #[error( + "Storage is not synced. Storage height: {storage_height}, requested height: \ + {requested_height}." + )] + StorageNotSynced { storage_height: BlockNumber, requested_height: BlockNumber }, #[error("Time to deadline is out of range. Got {deadline}.")] TimeToDeadlineError { deadline: chrono::DateTime }, } From 2b5a1762b8ea74e142b9aa34b661485e767e92c5 Mon Sep 17 00:00:00 2001 From: Yair Bakalchuk Date: Tue, 8 Oct 2024 10:22:57 +0300 Subject: [PATCH 21/57] feat(batcher): prepare proposal manager to be mocked in batcher tests --- crates/batcher/src/batcher.rs | 24 +++++---- crates/batcher/src/batcher_test.rs | 46 ++++++++++++++++ crates/batcher/src/lib.rs | 2 + crates/batcher/src/proposal_manager.rs | 59 +++++++++++++-------- crates/batcher/src/proposal_manager_test.rs | 1 + 5 files changed, 100 insertions(+), 32 deletions(-) create mode 100644 crates/batcher/src/batcher_test.rs diff --git a/crates/batcher/src/batcher.rs b/crates/batcher/src/batcher.rs index 79b39e63ae9..c4c2514a20f 100644 --- a/crates/batcher/src/batcher.rs +++ b/crates/batcher/src/batcher.rs @@ -13,13 +13,13 @@ use tracing::error; use crate::block_builder::{BlockBuilderFactoryTrait, BlockBuilderResult, BlockBuilderTrait}; use crate::config::BatcherConfig; -use crate::proposal_manager::{ProposalManager, ProposalManagerError}; +use crate::proposal_manager::{ProposalManager, ProposalManagerError, ProposalManagerTrait}; pub struct Batcher { pub config: BatcherConfig, pub mempool_client: SharedMempoolClient, pub storage: Arc, - proposal_manager: ProposalManager, + proposal_manager: Box, } // TODO(Yael 7/10/2024): remove DummyBlockBuilderFactory and pass the real BlockBuilderFactory @@ -36,22 +36,17 @@ impl BlockBuilderFactoryTrait for DummyBlockBuilderFactory { } impl Batcher { - pub fn new( + fn new( config: BatcherConfig, mempool_client: SharedMempoolClient, storage: Arc, + proposal_manager: Box, ) -> Self { Self { config: config.clone(), mempool_client: mempool_client.clone(), storage: storage.clone(), - proposal_manager: ProposalManager::new( - config.proposal_manager.clone(), - mempool_client.clone(), - // TODO(Yael 7/10/2024) : Pass the real BlockBuilderFactory - Arc::new(DummyBlockBuilderFactory {}), - storage, - ), + proposal_manager, } } @@ -131,7 +126,14 @@ impl Batcher { pub fn create_batcher(config: BatcherConfig, mempool_client: SharedMempoolClient) -> Batcher { let (storage_reader, _storage_writer) = papyrus_storage::open_storage(config.storage.clone()) .expect("Failed to open batcher's storage"); - Batcher::new(config, mempool_client, Arc::new(storage_reader)) + let storage_reader = Arc::new(storage_reader); + let proposal_manager = Box::new(ProposalManager::new( + config.proposal_manager.clone(), + mempool_client.clone(), + Arc::new(DummyBlockBuilderFactory {}), + storage_reader.clone(), + )); + Batcher::new(config, mempool_client, storage_reader, proposal_manager) } #[cfg_attr(test, automock)] diff --git a/crates/batcher/src/batcher_test.rs b/crates/batcher/src/batcher_test.rs new file mode 100644 index 00000000000..b1a371cf980 --- /dev/null +++ b/crates/batcher/src/batcher_test.rs @@ -0,0 +1,46 @@ +use async_trait::async_trait; +use blockifier::blockifier::block::BlockNumberHashPair; +use futures::future::BoxFuture; +use mockall::automock; +use starknet_api::block::BlockNumber; +use starknet_api::executable_transaction::Transaction; +use starknet_batcher_types::batcher_types::ProposalId; + +use crate::proposal_manager::{ProposalManagerResult, ProposalManagerTrait}; + +// A wrapper trait to allow mocking the ProposalManagerTrait in tests. +#[automock] +trait ProposalManagerTraitWrapper: Send + Sync { + fn wrap_start_height(&mut self, height: BlockNumber) -> ProposalManagerResult<()>; + + fn wrap_build_block_proposal( + &mut self, + proposal_id: ProposalId, + retrospective_block_hash: Option, + deadline: tokio::time::Instant, + output_content_sender: tokio::sync::mpsc::Sender, + ) -> BoxFuture<'_, ProposalManagerResult<()>>; +} + +#[async_trait] +impl ProposalManagerTrait for T { + fn start_height(&mut self, height: BlockNumber) -> ProposalManagerResult<()> { + self.wrap_start_height(height) + } + + async fn build_block_proposal( + &mut self, + proposal_id: ProposalId, + retrospective_block_hash: Option, + deadline: tokio::time::Instant, + output_content_sender: tokio::sync::mpsc::Sender, + ) -> ProposalManagerResult<()> { + self.wrap_build_block_proposal( + proposal_id, + retrospective_block_hash, + deadline, + output_content_sender, + ) + .await + } +} diff --git a/crates/batcher/src/lib.rs b/crates/batcher/src/lib.rs index 9e1fd83984f..d7063ebc7bf 100644 --- a/crates/batcher/src/lib.rs +++ b/crates/batcher/src/lib.rs @@ -1,4 +1,6 @@ pub mod batcher; +#[cfg(test)] +mod batcher_test; pub mod block_builder; pub mod communication; pub mod config; diff --git a/crates/batcher/src/proposal_manager.rs b/crates/batcher/src/proposal_manager.rs index 2522cc12faf..1f95845260a 100644 --- a/crates/batcher/src/proposal_manager.rs +++ b/crates/batcher/src/proposal_manager.rs @@ -1,6 +1,7 @@ use std::collections::BTreeMap; use std::sync::Arc; +use async_trait::async_trait; use blockifier::blockifier::block::BlockNumberHashPair; use papyrus_config::dumping::{ser_param, SerializeConfig}; use papyrus_config::{ParamPath, ParamPrivacyInput, SerializedParam}; @@ -87,6 +88,19 @@ pub enum ProposalManagerError { pub type ProposalManagerResult = Result; +#[async_trait] +pub trait ProposalManagerTrait: Send + Sync { + fn start_height(&mut self, height: BlockNumber) -> ProposalManagerResult<()>; + + async fn build_block_proposal( + &mut self, + proposal_id: ProposalId, + retrospective_block_hash: Option, + deadline: tokio::time::Instant, + output_content_sender: tokio::sync::mpsc::Sender, + ) -> ProposalManagerResult<()>; +} + /// Main struct for handling block proposals. /// Taking care of: /// - Proposing new blocks. @@ -112,28 +126,11 @@ pub(crate) struct ProposalManager { type ActiveTaskHandle = tokio::task::JoinHandle>; -impl ProposalManager { - pub fn new( - config: ProposalManagerConfig, - mempool_client: SharedMempoolClient, - block_builder_factory: Arc, - storage_reader: Arc, - ) -> Self { - Self { - config, - mempool_client, - storage_reader, - active_proposal: Arc::new(Mutex::new(None)), - block_builder_factory, - active_proposal_handle: None, - active_height: None, - proposals: Vec::new(), - } - } - +#[async_trait] +impl ProposalManagerTrait for ProposalManager { /// Starts working on the given height. #[instrument(skip(self), err)] - pub fn start_height(&mut self, height: BlockNumber) -> ProposalManagerResult<()> { + fn start_height(&mut self, height: BlockNumber) -> ProposalManagerResult<()> { // TODO: handle the case when `next_height==height && active_height, @@ -202,6 +199,26 @@ impl ProposalManager { Ok(()) } +} + +impl ProposalManager { + pub fn new( + config: ProposalManagerConfig, + mempool_client: SharedMempoolClient, + block_builder_factory: Arc, + storage_reader: Arc, + ) -> Self { + Self { + config, + mempool_client, + storage_reader, + active_proposal: Arc::new(Mutex::new(None)), + block_builder_factory, + active_proposal_handle: None, + active_height: None, + proposals: Vec::new(), + } + } // Checks if there is already a proposal being generated, and if not, sets the given proposal_id // as the one being generated. diff --git a/crates/batcher/src/proposal_manager_test.rs b/crates/batcher/src/proposal_manager_test.rs index 083d9eb5444..f6ade46321e 100644 --- a/crates/batcher/src/proposal_manager_test.rs +++ b/crates/batcher/src/proposal_manager_test.rs @@ -31,6 +31,7 @@ use crate::proposal_manager::{ ProposalManagerConfig, ProposalManagerError, ProposalManagerResult, + ProposalManagerTrait, }; pub type OutputTxStream = ReceiverStream; From 26a941fa5d2feb5730bf039fb5d1b358a35cff79 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 12:24:57 +0300 Subject: [PATCH 22/57] refactor(blockifier,starknet_api): gas amount is now a u64, not a u128 (#1175) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1175) --- crates/blockifier/src/bouncer.rs | 4 +- .../blockifier/src/execution/entry_point.rs | 15 ++---- crates/blockifier/src/fee/fee_test.rs | 48 ++++++++++++++----- crates/blockifier/src/fee/gas_usage.rs | 8 ++-- crates/blockifier/src/fee/gas_usage_test.rs | 15 +++--- crates/blockifier/src/fee/receipt_test.rs | 29 ++++++----- crates/blockifier/src/fee/resources.rs | 47 +++++++++++++----- crates/blockifier/src/test_utils.rs | 4 +- .../transaction/account_transactions_test.rs | 13 +++-- .../src/transaction/execution_flavors_test.rs | 26 +++++----- .../blockifier/src/transaction/test_utils.rs | 14 ++---- .../src/transaction/transactions_test.rs | 8 ++-- crates/blockifier/src/utils.rs | 6 --- crates/blockifier/src/versioned_constants.rs | 7 ++- .../src/py_block_executor.rs | 8 ++-- crates/starknet_api/src/block.rs | 5 +- .../starknet_api/src/execution_resources.rs | 12 +++-- crates/starknet_api/src/transaction.rs | 35 ++++++++------ crates/starknet_api/src/transaction_test.rs | 25 ++++++++-- 19 files changed, 192 insertions(+), 137 deletions(-) diff --git a/crates/blockifier/src/bouncer.rs b/crates/blockifier/src/bouncer.rs index 039f3785788..943d78ac2ed 100644 --- a/crates/blockifier/src/bouncer.rs +++ b/crates/blockifier/src/bouncer.rs @@ -16,7 +16,7 @@ use crate::state::cached_state::{StateChangesKeys, StorageEntry}; use crate::state::state_api::StateReader; use crate::transaction::errors::TransactionExecutionError; use crate::transaction::objects::{ExecutionResourcesTraits, TransactionExecutionResult}; -use crate::utils::usize_from_u128; +use crate::utils::usize_from_u64; #[cfg(test)] #[path = "bouncer_test.rs"] @@ -346,7 +346,7 @@ pub fn get_tx_weights( state_changes_keys: &StateChangesKeys, ) -> TransactionExecutionResult { let message_resources = &tx_resources.starknet_resources.messages; - let message_starknet_gas = usize_from_u128(message_resources.get_starknet_gas_cost().l1_gas.0) + let message_starknet_gas = usize_from_u64(message_resources.get_starknet_gas_cost().l1_gas.0) .expect("This conversion should not fail as the value is a converted usize."); let mut additional_os_resources = get_casm_hash_calculation_resources(state_reader, executed_class_hashes)?; diff --git a/crates/blockifier/src/execution/entry_point.rs b/crates/blockifier/src/execution/entry_point.rs index c2385aa7eba..1376dba8d07 100644 --- a/crates/blockifier/src/execution/entry_point.rs +++ b/crates/blockifier/src/execution/entry_point.rs @@ -278,10 +278,10 @@ impl EntryPointExecutionContext { // New transactions derive the step limit by the L1 gas resource bounds; deprecated // transactions derive this value from the `max_fee`. let tx_gas_upper_bound = match tx_info { - TransactionInfo::Deprecated(context) => { - context.max_fee - / block_info.gas_prices.get_l1_gas_price_by_fee_type(&tx_info.fee_type()) - } + // Fee is a larger uint type than GasAmount, so we need to saturate the division. + TransactionInfo::Deprecated(context) => context.max_fee.saturating_div( + block_info.gas_prices.get_l1_gas_price_by_fee_type(&tx_info.fee_type()), + ), TransactionInfo::Current(context) => context.l1_resource_bounds().max_amount.into(), }; @@ -291,12 +291,7 @@ impl EntryPointExecutionContext { let upper_bound_u64 = if gas_per_step.is_zero() { u64::MAX } else { - // TODO: This panic will disappear once GasAmount is a u64. - (gas_per_step.inv() - * u64::try_from(tx_gas_upper_bound.0).unwrap_or_else(|_| { - panic!("Gas amounts cannot be more than 64 bits; got {tx_gas_upper_bound:?}.") - })) - .to_integer() + (gas_per_step.inv() * tx_gas_upper_bound.0).to_integer() }; let tx_upper_bound = usize_from_u64(upper_bound_u64).unwrap_or_else(|_| { log::warn!( diff --git a/crates/blockifier/src/fee/fee_test.rs b/crates/blockifier/src/fee/fee_test.rs index ad06c097a5e..dfe067a8b9a 100644 --- a/crates/blockifier/src/fee/fee_test.rs +++ b/crates/blockifier/src/fee/fee_test.rs @@ -28,7 +28,7 @@ use crate::test_utils::{ }; use crate::transaction::objects::FeeType; use crate::transaction::test_utils::{account_invoke_tx, all_resource_bounds, l1_resource_bounds}; -use crate::utils::{u128_from_usize, u64_from_usize}; +use crate::utils::u64_from_usize; use crate::versioned_constants::VersionedConstants; #[rstest] @@ -66,7 +66,7 @@ fn test_simple_get_vm_resource_usage( let n_reverted_steps = 0; vm_resource_usage.n_steps = vm_resource_usage.builtin_instance_counter.get(&BuiltinName::range_check).unwrap() - 1; - let vm_usage_in_l1_gas = u128_from_usize( + let vm_usage_in_l1_gas = u64_from_usize( *vm_resource_usage.builtin_instance_counter.get(&BuiltinName::range_check).unwrap(), ) .into(); @@ -155,9 +155,9 @@ fn test_float_get_vm_resource_usage( fn test_discounted_gas_overdraft( #[case] gas_price: u128, #[case] data_gas_price: u128, - #[case] l1_gas_used: u128, - #[case] l1_data_gas_used: u128, - #[case] gas_bound: u128, + #[case] l1_gas_used: u64, + #[case] l1_data_gas_used: u64, + #[case] gas_bound: u64, #[case] expect_failure: bool, ) { let (l1_gas_used, l1_data_gas_used, gas_bound) = @@ -207,7 +207,9 @@ fn test_discounted_gas_overdraft( if expect_failure { let error = report.error().unwrap(); let expected_actual_amount = l1_gas_used - + (l1_data_gas_used.nonzero_checked_mul(data_gas_price).unwrap()) / gas_price; + + (l1_data_gas_used.nonzero_checked_mul(data_gas_price).unwrap()) + .checked_div(gas_price) + .unwrap(); assert_matches!( error, FeeCheckError::MaxGasAmountExceeded { resource, max_amount, actual_amount } if max_amount == gas_bound @@ -292,13 +294,10 @@ fn test_post_execution_gas_overdraft_all_resource_bounds( #[case::happy_flow_l1_gas_only(10, 0, 0, 10, 2*10)] #[case::happy_flow_no_l2_gas(10, 20, 0, 10 + 3*20, 2*10 + 4*20)] #[case::happy_flow_all(10, 20, 30, 10 + 3*20 + 5*30, 2*10 + 4*20 + 6*30)] -#[case::saturating_l1_gas(u128::MAX, 1, 1, u128::MAX, u128::MAX)] -#[case::saturating_l1_data_gas(1, u128::MAX, 1, u128::MAX, u128::MAX)] -#[case::saturating_l2_gas(1, 1, u128::MAX, u128::MAX, u128::MAX)] fn test_get_fee_by_gas_vector_regression( - #[case] l1_gas: u128, - #[case] l1_data_gas: u128, - #[case] l2_gas: u128, + #[case] l1_gas: u64, + #[case] l1_data_gas: u64, + #[case] l2_gas: u64, #[case] expected_fee_eth: u128, #[case] expected_fee_strk: u128, ) { @@ -322,3 +321,28 @@ fn test_get_fee_by_gas_vector_regression( Fee(expected_fee_strk) ); } + +#[rstest] +#[case::l1_saturates(u64::MAX, 0, 0)] +#[case::l1_data_saturates(0, u64::MAX, 0)] +#[case::l2_gas_saturates(0, 0, u64::MAX)] +// TODO: Add L2 saturation case once `get_fee_by_gas_vector` implements L2 collection. +fn test_get_fee_by_gas_vector_saturation( + #[case] l1_gas: u64, + #[case] l1_data_gas: u64, + #[case] l2_gas: u64, +) { + let huge_gas_price = NonzeroGasPrice::try_from(2_u128 * u128::from(u64::MAX)).unwrap(); + let mut block_info = BlockContext::create_for_account_testing().block_info; + block_info.gas_prices = GasPrices::new( + huge_gas_price, + huge_gas_price, + huge_gas_price, + huge_gas_price, + huge_gas_price, + huge_gas_price, + ); + let gas_vector = + GasVector { l1_gas: l1_gas.into(), l1_data_gas: l1_data_gas.into(), l2_gas: l2_gas.into() }; + assert_eq!(get_fee_by_gas_vector(&block_info, gas_vector, &FeeType::Eth), Fee(u128::MAX)); +} diff --git a/crates/blockifier/src/fee/gas_usage.rs b/crates/blockifier/src/fee/gas_usage.rs index 49d3896e78e..36fbda8b599 100644 --- a/crates/blockifier/src/fee/gas_usage.rs +++ b/crates/blockifier/src/fee/gas_usage.rs @@ -8,7 +8,7 @@ use crate::fee::eth_gas_constants; use crate::fee::resources::GasVector; use crate::state::cached_state::StateChangesCount; use crate::transaction::account_transaction::AccountTransaction; -use crate::utils::u128_from_usize; +use crate::utils::u64_from_usize; #[cfg(test)] #[path = "gas_usage_test.rs"] @@ -43,7 +43,7 @@ pub fn get_da_gas_cost(state_changes_count: &StateChangesCount, use_kzg_da: bool let (l1_gas, blob_gas) = if use_kzg_da { ( 0_u8.into(), - u128_from_usize( + u64_from_usize( onchain_data_segment_length * eth_gas_constants::DATA_GAS_PER_FIELD_ELEMENT, ) .into(), @@ -71,7 +71,7 @@ pub fn get_da_gas_cost(state_changes_count: &StateChangesCount, use_kzg_da: bool naive_cost - discount }; - (u128_from_usize(gas).into(), 0_u8.into()) + (u64_from_usize(gas).into(), 0_u8.into()) }; GasVector { l1_gas, l1_data_gas: blob_gas, ..Default::default() } @@ -136,7 +136,7 @@ pub fn get_log_message_to_l1_emissions_cost(l2_to_l1_payload_lengths: &[usize]) fn get_event_emission_cost(n_topics: usize, data_length: usize) -> GasVector { GasVector::from_l1_gas( - u128_from_usize( + u64_from_usize( eth_gas_constants::GAS_PER_LOG + (n_topics + constants::N_DEFAULT_TOPICS) * eth_gas_constants::GAS_PER_LOG_TOPIC + data_length * eth_gas_constants::GAS_PER_LOG_DATA_WORD, diff --git a/crates/blockifier/src/fee/gas_usage_test.rs b/crates/blockifier/src/fee/gas_usage_test.rs index b96f6ad2889..ca148f9a6fa 100644 --- a/crates/blockifier/src/fee/gas_usage_test.rs +++ b/crates/blockifier/src/fee/gas_usage_test.rs @@ -29,7 +29,7 @@ use crate::test_utils::{ }; use crate::transaction::objects::FeeType; use crate::transaction::test_utils::account_invoke_tx; -use crate::utils::{u128_from_usize, u64_from_usize}; +use crate::utils::u64_from_usize; use crate::versioned_constants::{ ResourceCost, StarknetVersion, @@ -204,7 +204,7 @@ fn test_get_da_gas_cost_basic(#[case] state_changes_count: StateChangesCount) { let computed_gas_vector = get_da_gas_cost(&state_changes_count, true); assert_eq!( - GasVector::from_l1_data_gas(u128_from_usize(manual_blob_gas_usage).into()), + GasVector::from_l1_data_gas(u64_from_usize(manual_blob_gas_usage).into()), computed_gas_vector ); } @@ -253,10 +253,7 @@ fn test_onchain_data_discount() { let cost_without_discount = (state_changes_count.n_storage_updates * 2) * (512 + 100); let actual_cost = get_da_gas_cost(&state_changes_count, use_kzg_da).l1_gas; - let cost_ratio = ResourceCost::new( - u64::try_from(actual_cost.0).unwrap(), - u64_from_usize(cost_without_discount), - ); + let cost_ratio = ResourceCost::new(actual_cost.0, u64_from_usize(cost_without_discount)); assert!(cost_ratio <= ResourceCost::new(9, 10)); assert!(cost_ratio >= ResourceCost::new(88, 100)); } @@ -294,10 +291,12 @@ fn test_discounted_gas_from_gas_vector_computation() { let result_div_ceil = gas_usage.l1_gas + (gas_usage.l1_data_gas.nonzero_checked_mul(DEFAULT_ETH_L1_DATA_GAS_PRICE).unwrap()) - .div_ceil(DEFAULT_ETH_L1_GAS_PRICE); + .checked_div_ceil(DEFAULT_ETH_L1_GAS_PRICE) + .unwrap(); let result_div_floor = gas_usage.l1_gas + (gas_usage.l1_data_gas.nonzero_checked_mul(DEFAULT_ETH_L1_DATA_GAS_PRICE).unwrap()) - / DEFAULT_ETH_L1_GAS_PRICE; + .checked_div(DEFAULT_ETH_L1_GAS_PRICE) + .unwrap(); assert_eq!(actual_result, result_div_ceil); assert_eq!(actual_result, result_div_floor + 1_u8.into()); diff --git a/crates/blockifier/src/fee/receipt_test.rs b/crates/blockifier/src/fee/receipt_test.rs index 2b46e92d9ab..13654e6001d 100644 --- a/crates/blockifier/src/fee/receipt_test.rs +++ b/crates/blockifier/src/fee/receipt_test.rs @@ -30,7 +30,7 @@ use crate::transaction::test_utils::{ create_resource_bounds, }; use crate::transaction::transactions::ExecutableTransaction; -use crate::utils::{u128_from_usize, u64_from_usize, usize_from_u128}; +use crate::utils::{u64_from_usize, usize_from_u64}; use crate::versioned_constants::VersionedConstants; #[fixture] @@ -124,9 +124,9 @@ fn test_calculate_tx_gas_usage_basic<'a>( let gas_per_data_felt = versioned_constants .get_archival_data_gas_costs(&gas_vector_computation_mode) .gas_per_data_felt; - let calldata_and_signature_gas_cost = u128::from( - (gas_per_data_felt * u64_from_usize(calldata_length + signature_length)).to_integer(), - ) + let calldata_and_signature_gas_cost = (gas_per_data_felt + * u64_from_usize(calldata_length + signature_length)) + .to_integer() .into(); let manual_starknet_gas_usage_vector = match gas_vector_computation_mode { GasVectorComputationMode::NoL2Gas => { @@ -163,10 +163,9 @@ fn test_calculate_tx_gas_usage_basic<'a>( // Manual calculation. let message_segment_length = get_message_segment_length(&[], Some(l1_handler_payload_size)); - let calldata_and_signature_gas_cost = u128::from( - (gas_per_data_felt * u64_from_usize(l1_handler_payload_size + signature_length)) - .to_integer(), - ) + let calldata_and_signature_gas_cost = (gas_per_data_felt + * u64_from_usize(l1_handler_payload_size + signature_length)) + .to_integer() .into(); let calldata_and_signature_gas_cost_vector = match gas_vector_computation_mode { GasVectorComputationMode::NoL2Gas => { @@ -177,16 +176,16 @@ fn test_calculate_tx_gas_usage_basic<'a>( let manual_starknet_l1_gas_usage = message_segment_length * eth_gas_constants::GAS_PER_MEMORY_WORD + eth_gas_constants::GAS_PER_COUNTER_DECREASE - + usize_from_u128( + + usize_from_u64( get_consumed_message_to_l2_emissions_cost(Some(l1_handler_payload_size)).l1_gas.0, ) .unwrap(); let manual_starknet_l1_gas_usage_vector = - GasVector::from_l1_gas(u128_from_usize(manual_starknet_l1_gas_usage).into()); + GasVector::from_l1_gas(u64_from_usize(manual_starknet_l1_gas_usage).into()); let manual_sharp_gas_usage = message_segment_length * eth_gas_constants::SHARP_GAS_PER_MEMORY_WORD; let manual_gas_computation = - GasVector::from_l1_gas(u128_from_usize(manual_sharp_gas_usage).into()) + GasVector::from_l1_gas(u64_from_usize(manual_sharp_gas_usage).into()) + manual_starknet_l1_gas_usage_vector + calldata_and_signature_gas_cost_vector; assert_eq!(l1_handler_gas_usage_vector, manual_gas_computation); @@ -245,16 +244,16 @@ fn test_calculate_tx_gas_usage_basic<'a>( let n_l2_to_l1_messages = l2_to_l1_payload_lengths.len(); let manual_starknet_gas_usage = message_segment_length * eth_gas_constants::GAS_PER_MEMORY_WORD + n_l2_to_l1_messages * eth_gas_constants::GAS_PER_ZERO_TO_NONZERO_STORAGE_SET - + usize_from_u128(get_log_message_to_l1_emissions_cost(&l2_to_l1_payload_lengths).l1_gas.0) + + usize_from_u64(get_log_message_to_l1_emissions_cost(&l2_to_l1_payload_lengths).l1_gas.0) .unwrap(); let manual_sharp_gas_usage = message_segment_length * eth_gas_constants::SHARP_GAS_PER_MEMORY_WORD - + usize_from_u128(l2_to_l1_starknet_resources.state.to_gas_vector(use_kzg_da).l1_gas.0) + + usize_from_u64(l2_to_l1_starknet_resources.state.to_gas_vector(use_kzg_da).l1_gas.0) .unwrap(); let manual_sharp_blob_gas_usage = l2_to_l1_starknet_resources.state.to_gas_vector(use_kzg_da).l1_data_gas; let manual_gas_computation = GasVector { - l1_gas: u128_from_usize(manual_starknet_gas_usage + manual_sharp_gas_usage).into(), + l1_gas: u64_from_usize(manual_starknet_gas_usage + manual_sharp_gas_usage).into(), l1_data_gas: manual_sharp_blob_gas_usage, ..Default::default() }; @@ -329,7 +328,7 @@ fn test_calculate_tx_gas_usage_basic<'a>( + storage_writings_gas_usage_vector.l1_gas // l2_to_l1_messages_gas_usage and storage_writings_gas_usage got a discount each, while // the combined calculation got it once. - + u128_from_usize(fee_balance_discount).into(), + + u64_from_usize(fee_balance_discount).into(), // Expected blob gas usage is from data availability only. l1_data_gas: combined_cases_starknet_resources.state.to_gas_vector(use_kzg_da).l1_data_gas, l2_gas: l1_handler_gas_usage_vector.l2_gas, diff --git a/crates/blockifier/src/fee/resources.rs b/crates/blockifier/src/fee/resources.rs index 2a111b22eed..dc6b894274b 100644 --- a/crates/blockifier/src/fee/resources.rs +++ b/crates/blockifier/src/fee/resources.rs @@ -19,7 +19,7 @@ use crate::fee::gas_usage::{ use crate::state::cached_state::{StateChanges, StateChangesCount}; use crate::transaction::errors::TransactionFeeError; use crate::transaction::objects::HasRelatedFeeType; -use crate::utils::{u128_from_usize, u64_from_usize}; +use crate::utils::u64_from_usize; use crate::versioned_constants::{ resource_cost_to_u128_ratio, ArchivalDataGasCosts, @@ -219,12 +219,24 @@ impl ArchivalDataResources { /// Returns the cost of the transaction's emmited events in L1/L2 gas units, depending on the /// mode. fn get_events_gas_cost(&self, archival_gas_costs: &ArchivalDataGasCosts) -> GasAmount { - (resource_cost_to_u128_ratio(archival_gas_costs.gas_per_data_felt) - * (resource_cost_to_u128_ratio(archival_gas_costs.event_key_factor) - * self.event_summary.total_event_keys - + self.event_summary.total_event_data_size)) - .to_integer() - .into() + u64::try_from( + (resource_cost_to_u128_ratio(archival_gas_costs.gas_per_data_felt) + * (resource_cost_to_u128_ratio(archival_gas_costs.event_key_factor) + * self.event_summary.total_event_keys + + self.event_summary.total_event_data_size)) + .to_integer(), + ) + .unwrap_or_else(|_| { + panic!( + "Events gas cost overflowed: {} event keys (factor: {}), data length {} (at {} \ + gas per felt).", + self.event_summary.total_event_keys, + archival_gas_costs.event_key_factor, + self.event_summary.total_event_data_size, + archival_gas_costs.gas_per_data_felt + ) + }) + .into() } } @@ -251,7 +263,7 @@ impl MessageResources { pub fn to_gas_vector(&self) -> GasVector { let starknet_gas_usage = self.get_starknet_gas_cost(); let sharp_gas_usage = GasVector::from_l1_gas( - u128_from_usize( + u64_from_usize( self.message_segment_length * eth_gas_constants::SHARP_GAS_PER_MEMORY_WORD, ) .into(), @@ -268,7 +280,7 @@ impl MessageResources { GasVector::from_l1_gas( // Starknet's updateState gets the message segment as an argument. - u128_from_usize( + u64_from_usize( self.message_segment_length * eth_gas_constants::GAS_PER_MEMORY_WORD // Starknet's updateState increases a (storage) counter for each L2-to-L1 message. + n_l2_to_l1_messages * eth_gas_constants::GAS_PER_ZERO_TO_NONZERO_STORAGE_SET @@ -360,8 +372,19 @@ impl GasVector { pub fn to_discounted_l1_gas(&self, tx_context: &TransactionContext) -> GasAmount { let gas_prices = &tx_context.block_context.block_info.gas_prices; let fee_type = tx_context.tx_info.fee_type(); - let gas_price = gas_prices.get_l1_gas_price_by_fee_type(&fee_type); - let data_gas_price = gas_prices.get_l1_data_gas_price_by_fee_type(&fee_type); - self.l1_gas + (self.l1_data_gas.nonzero_saturating_mul(data_gas_price)).div_ceil(gas_price) + let l1_gas_price = gas_prices.get_l1_gas_price_by_fee_type(&fee_type); + let l1_data_gas_price = gas_prices.get_l1_data_gas_price_by_fee_type(&fee_type); + let l1_data_gas_fee = self.l1_data_gas.nonzero_saturating_mul(l1_data_gas_price); + let l1_data_gas_in_l1_gas_units = + l1_data_gas_fee.checked_div_ceil(l1_gas_price).unwrap_or_else(|| { + log::warn!( + "Discounted L1 gas cost overflowed: division of L1 data fee {:?} by regular \ + L1 gas price ({:?}) resulted in overflow.", + l1_data_gas_fee, + l1_gas_price + ); + GasAmount::MAX + }); + self.l1_gas.saturating_add(l1_data_gas_in_l1_gas_units) } } diff --git a/crates/blockifier/src/test_utils.rs b/crates/blockifier/src/test_utils.rs index efa7cdc67e6..4cff55bf93b 100644 --- a/crates/blockifier/src/test_utils.rs +++ b/crates/blockifier/src/test_utils.rs @@ -113,10 +113,10 @@ pub const DEFAULT_ETH_L1_DATA_GAS_PRICE: NonzeroGasPrice = NonzeroGasPrice::new_unchecked(GasPrice(u128::pow(10, 6))); // Given in units of Wei. pub const DEFAULT_STRK_L1_DATA_GAS_PRICE: NonzeroGasPrice = NonzeroGasPrice::new_unchecked(GasPrice(u128::pow(10, 9))); // Given in units of STRK. -pub const DEFAULT_L1_DATA_GAS_MAX_AMOUNT: GasAmount = GasAmount(u128::pow(10, 6)); +pub const DEFAULT_L1_DATA_GAS_MAX_AMOUNT: GasAmount = GasAmount(u64::pow(10, 6)); pub const DEFAULT_STRK_L2_GAS_PRICE: NonzeroGasPrice = NonzeroGasPrice::new_unchecked(GasPrice(u128::pow(10, 9))); -pub const DEFAULT_L2_GAS_MAX_AMOUNT: GasAmount = GasAmount(u128::pow(10, 6)); +pub const DEFAULT_L2_GAS_MAX_AMOUNT: GasAmount = GasAmount(u64::pow(10, 6)); // The block number of the BlockContext being used for testing. pub const CURRENT_BLOCK_NUMBER: u64 = 2001; diff --git a/crates/blockifier/src/transaction/account_transactions_test.rs b/crates/blockifier/src/transaction/account_transactions_test.rs index 4f6bd05e1b0..fe554f81897 100644 --- a/crates/blockifier/src/transaction/account_transactions_test.rs +++ b/crates/blockifier/src/transaction/account_transactions_test.rs @@ -88,7 +88,7 @@ use crate::transaction::test_utils::{ }; use crate::transaction::transaction_types::TransactionType; use crate::transaction::transactions::{DeclareTransaction, ExecutableTransaction, ExecutionFlags}; -use crate::utils::u128_from_usize; +use crate::utils::u64_from_usize; #[rstest] fn test_circuit(block_context: BlockContext, max_l1_resource_bounds: ValidResourceBounds) { @@ -173,7 +173,10 @@ fn test_fee_enforcement( deploy_account_tx_args! { class_hash: account.get_class_hash(), max_fee: Fee(u128::from(!zero_bounds)), - resource_bounds: l1_resource_bounds(u128::from(!zero_bounds).into(), DEFAULT_STRK_L1_GAS_PRICE.into()), + resource_bounds: l1_resource_bounds( + u8::from(!zero_bounds).into(), + DEFAULT_STRK_L1_GAS_PRICE.into() + ), version, }, &mut NonceManager::default(), @@ -991,13 +994,13 @@ fn test_max_fee_to_max_steps_conversion( ) { let TestInitData { mut state, account_address, contract_address, mut nonce_manager } = create_test_init_data(&block_context.chain_info, CairoVersion::Cairo0); - let actual_gas_used: GasAmount = u128_from_usize( + let actual_gas_used: GasAmount = u64_from_usize( get_syscall_resources(SyscallSelector::CallContract).n_steps + get_tx_resources(TransactionType::InvokeFunction).n_steps + 1751, ) .into(); - let actual_fee = actual_gas_used.0 * 100000000000; + let actual_fee = u128::from(actual_gas_used.0) * 100000000000; let actual_strk_gas_price = block_context.block_info.gas_prices.get_l1_gas_price_by_fee_type(&FeeType::Strk); let execute_calldata = create_calldata( @@ -1088,7 +1091,7 @@ fn test_insufficient_max_fee_reverts( let actual_fee_depth1 = tx_execution_info1.receipt.fee; let gas_price = block_context.block_info.gas_prices.get_l1_gas_price_by_fee_type(&FeeType::Strk); - let gas_ammount = actual_fee_depth1 / gas_price; + let gas_ammount = actual_fee_depth1.checked_div(gas_price).unwrap(); // Invoke the `recurse` function with depth of 2 and the actual fee of depth 1 as max_fee. // This call should fail due to insufficient max fee (steps bound based on max_fee is not so diff --git a/crates/blockifier/src/transaction/execution_flavors_test.rs b/crates/blockifier/src/transaction/execution_flavors_test.rs index 83ae1d7203a..c1f77cc400e 100644 --- a/crates/blockifier/src/transaction/execution_flavors_test.rs +++ b/crates/blockifier/src/transaction/execution_flavors_test.rs @@ -51,7 +51,7 @@ use crate::transaction::test_utils::{ }; use crate::transaction::transaction_types::TransactionType; use crate::transaction::transactions::ExecutableTransaction; -use crate::utils::u128_from_usize; +use crate::utils::u64_from_usize; const VALIDATE_GAS_OVERHEAD: GasAmount = GasAmount(21); struct FlavorTestInitialState { @@ -287,7 +287,7 @@ fn test_simulate_validate_pre_validate_with_charge_fee( // Second scenario: resource bounds greater than balance. let gas_price = block_context.block_info.gas_prices.get_l1_gas_price_by_fee_type(&fee_type); - let balance_over_gas_price = BALANCE / gas_price; + let balance_over_gas_price = BALANCE.checked_div(gas_price).unwrap(); let result = account_invoke_tx(invoke_tx_args! { max_fee: Fee(BALANCE.0 + 1), resource_bounds: l1_resource_bounds( @@ -371,7 +371,7 @@ fn test_simulate_validate_pre_validate_not_charge_fee( let base_gas = calculate_actual_gas(&tx_execution_info, &block_context, false); assert!( base_gas - > u128_from_usize( + > u64_from_usize( get_syscall_resources(SyscallSelector::CallContract).n_steps + get_tx_resources(TransactionType::InvokeFunction).n_steps ) @@ -405,7 +405,7 @@ fn test_simulate_validate_pre_validate_not_charge_fee( // Second scenario: resource bounds greater than balance. let gas_price = block_context.block_info.gas_prices.get_l1_gas_price_by_fee_type(&fee_type); - let balance_over_gas_price = BALANCE / gas_price; + let balance_over_gas_price = BALANCE.checked_div(gas_price).unwrap(); execute_and_check_gas_and_fee!( Fee(BALANCE.0 + 1), l1_resource_bounds((balance_over_gas_price.0 + 10).into(), gas_price.into()) @@ -512,8 +512,7 @@ fn test_simulate_charge_fee_no_validation_fail_validate( let block_context = BlockContext::create_for_account_testing(); let base_gas = calculate_actual_gas(&tx_execution_info, &block_context, validate); assert!( - base_gas - > u128_from_usize(get_tx_resources(TransactionType::InvokeFunction).n_steps).into() + base_gas > u64_from_usize(get_tx_resources(TransactionType::InvokeFunction).n_steps).into() ); let (actual_gas_used, actual_fee) = gas_and_fee(base_gas, validate, &fee_type); @@ -581,8 +580,7 @@ fn test_simulate_validate_charge_fee_mid_execution( let base_gas = calculate_actual_gas(&tx_execution_info, &block_context, validate); let (revert_gas_used, revert_fee) = gas_and_fee(base_gas, validate, &fee_type); assert!( - base_gas - > u128_from_usize(get_tx_resources(TransactionType::InvokeFunction).n_steps).into() + base_gas > u64_from_usize(get_tx_resources(TransactionType::InvokeFunction).n_steps).into() ); assert!(tx_execution_info.is_reverted()); check_gas_and_fee( @@ -609,7 +607,7 @@ fn test_simulate_validate_charge_fee_mid_execution( // used. Otherwise, execution is limited by block bounds, so more resources will be used. let (limited_gas_used, limited_fee) = gas_and_fee(7763_u32.into(), validate, &fee_type); let (unlimited_gas_used, unlimited_fee) = gas_and_fee( - u128_from_usize( + u64_from_usize( get_syscall_resources(SyscallSelector::CallContract).n_steps + get_tx_resources(TransactionType::InvokeFunction).n_steps + 5730, @@ -658,7 +656,7 @@ fn test_simulate_validate_charge_fee_mid_execution( // lower when `validate` is true, but this is not reflected in the actual gas usage. let invoke_tx_max_n_steps_as_u64: u64 = low_step_block_context.versioned_constants.invoke_tx_max_n_steps.into(); - let block_limit_gas = u128::from(invoke_tx_max_n_steps_as_u64 + 1652).into(); + let block_limit_gas = (invoke_tx_max_n_steps_as_u64 + 1652).into(); let block_limit_fee = get_fee_by_gas_vector( &block_context.block_info, GasVector::from_l1_gas(block_limit_gas), @@ -732,12 +730,12 @@ fn test_simulate_validate_charge_fee_post_execution( // `__validate__` and overhead resources + number of reverted steps, comes out slightly more // than the gas bound. let (revert_gas_usage, revert_fee) = gas_and_fee( - (u128_from_usize(get_tx_resources(TransactionType::InvokeFunction).n_steps) + 5730).into(), + (u64_from_usize(get_tx_resources(TransactionType::InvokeFunction).n_steps) + 5730).into(), validate, &fee_type, ); let (unlimited_gas_used, unlimited_fee) = gas_and_fee( - u128_from_usize( + u64_from_usize( get_syscall_resources(SyscallSelector::CallContract).n_steps + get_tx_resources(TransactionType::InvokeFunction).n_steps + 5730, @@ -782,7 +780,7 @@ fn test_simulate_validate_charge_fee_post_execution( // Second scenario: balance too low. // Execute a transfer, and make sure we get the expected result. let (success_actual_gas, actual_fee) = gas_and_fee( - u128_from_usize( + u64_from_usize( get_syscall_resources(SyscallSelector::CallContract).n_steps + get_tx_resources(TransactionType::InvokeFunction).n_steps + 4260, @@ -792,7 +790,7 @@ fn test_simulate_validate_charge_fee_post_execution( &fee_type, ); let (fail_actual_gas, fail_actual_fee) = gas_and_fee( - u128_from_usize(get_tx_resources(TransactionType::InvokeFunction).n_steps + 2252).into(), + u64_from_usize(get_tx_resources(TransactionType::InvokeFunction).n_steps + 2252).into(), validate, &fee_type, ); diff --git a/crates/blockifier/src/transaction/test_utils.rs b/crates/blockifier/src/transaction/test_utils.rs index b1ba7a91a7a..4540acd7d2c 100644 --- a/crates/blockifier/src/transaction/test_utils.rs +++ b/crates/blockifier/src/transaction/test_utils.rs @@ -331,7 +331,7 @@ pub fn run_invoke_tx( // TODO: Check usages of this function and update to using all gas bounds. pub fn l1_resource_bounds(max_amount: GasAmount, max_price: GasPrice) -> ValidResourceBounds { ValidResourceBounds::L1Gas(ResourceBounds { - max_amount: max_amount.0.try_into().unwrap(), + max_amount: max_amount.0, max_price_per_unit: max_price.0, }) } @@ -364,16 +364,10 @@ pub fn create_all_resource_bounds( l1_data_max_price: GasPrice, ) -> ValidResourceBounds { ValidResourceBounds::AllResources(AllResourceBounds { - l1_gas: ResourceBounds { - max_amount: l1_max_amount.0.try_into().unwrap(), - max_price_per_unit: l1_max_price.0, - }, - l2_gas: ResourceBounds { - max_amount: l2_max_amount.0.try_into().unwrap(), - max_price_per_unit: l2_max_price.0, - }, + l1_gas: ResourceBounds { max_amount: l1_max_amount.0, max_price_per_unit: l1_max_price.0 }, + l2_gas: ResourceBounds { max_amount: l2_max_amount.0, max_price_per_unit: l2_max_price.0 }, l1_data_gas: ResourceBounds { - max_amount: l1_data_max_amount.0.try_into().unwrap(), + max_amount: l1_data_max_amount.0, max_price_per_unit: l1_data_max_price.0, }, }) diff --git a/crates/blockifier/src/transaction/transactions_test.rs b/crates/blockifier/src/transaction/transactions_test.rs index cc1b30c9be0..4db197658cb 100644 --- a/crates/blockifier/src/transaction/transactions_test.rs +++ b/crates/blockifier/src/transaction/transactions_test.rs @@ -905,7 +905,7 @@ fn test_max_fee_exceeds_balance( let invalid_max_fee = Fee(BALANCE.0 + 1); // TODO(Ori, 1/2/2024): Write an indicative expect message explaining why the conversion works. - let balance_over_gas_price = BALANCE / MAX_L1_GAS_PRICE; + let balance_over_gas_price = BALANCE.checked_div(MAX_L1_GAS_PRICE).unwrap(); let invalid_resource_bounds = l1_resource_bounds((balance_over_gas_price.0 + 1).into(), MAX_L1_GAS_PRICE.into()); @@ -983,15 +983,15 @@ fn test_insufficient_new_resource_bounds( let default_resource_bounds = AllResourceBounds { l1_gas: ResourceBounds { - max_amount: minimal_gas_vector.l1_gas.0.try_into().unwrap(), + max_amount: minimal_gas_vector.l1_gas.0, max_price_per_unit: actual_strk_l1_gas_price.get().0, }, l2_gas: ResourceBounds { - max_amount: minimal_gas_vector.l2_gas.0.try_into().unwrap(), + max_amount: minimal_gas_vector.l2_gas.0, max_price_per_unit: actual_strk_l2_gas_price.get().0, }, l1_data_gas: ResourceBounds { - max_amount: minimal_gas_vector.l1_data_gas.0.try_into().unwrap(), + max_amount: minimal_gas_vector.l1_data_gas.0, max_price_per_unit: actual_strk_l1_data_gas_price.get().0, }, }; diff --git a/crates/blockifier/src/utils.rs b/crates/blockifier/src/utils.rs index 9e70cf5f905..ef9c0a6c4d8 100644 --- a/crates/blockifier/src/utils.rs +++ b/crates/blockifier/src/utils.rs @@ -48,12 +48,6 @@ pub const fn const_max(a: u128, b: u128) -> u128 { [a, b][(a < b) as usize] } -/// Conversion from u128 to usize. This conversion should only be used if the value came from a -/// usize. -pub fn usize_from_u128(val: u128) -> Result { - val.try_into().map_err(|_| NumericConversionError::U128ToUsizeError(val)) -} - /// Conversion from u64 to usize. This conversion should only be used if the value came from a /// usize. pub fn usize_from_u64(val: u64) -> Result { diff --git a/crates/blockifier/src/versioned_constants.rs b/crates/blockifier/src/versioned_constants.rs index f31fc2781b6..48ccc7281c3 100644 --- a/crates/blockifier/src/versioned_constants.rs +++ b/crates/blockifier/src/versioned_constants.rs @@ -137,6 +137,8 @@ define_versioned_constants! { pub type ResourceCost = Ratio; +// TODO: Delete this ratio-converter function once event keys / data length are no longer 128 bits +// (no other usage is expected). pub fn resource_cost_to_u128_ratio(cost: ResourceCost) -> Ratio { Ratio::new((*cost.numer()).into(), (*cost.denom()).into()) } @@ -237,10 +239,7 @@ impl VersionedConstants { /// Converts from L1 gas amount to L2 gas amount with **upward rounding**. pub fn convert_l1_to_l2_gas_amount_round_up(&self, l1_gas_amount: GasAmount) -> GasAmount { // The amount ratio is the inverse of the price ratio. - (*(resource_cost_to_u128_ratio(self.l1_to_l2_gas_price_ratio().inv()) * l1_gas_amount.0) - .ceil() - .numer()) - .into() + (*(self.l1_to_l2_gas_price_ratio().inv() * l1_gas_amount.0).ceil().numer()).into() } /// Returns the following ratio: L2_gas_price/L1_gas_price. diff --git a/crates/native_blockifier/src/py_block_executor.rs b/crates/native_blockifier/src/py_block_executor.rs index 0b9a96c5520..59538aae360 100644 --- a/crates/native_blockifier/src/py_block_executor.rs +++ b/crates/native_blockifier/src/py_block_executor.rs @@ -11,7 +11,7 @@ use blockifier::fee::resources::GasVector; use blockifier::state::global_cache::GlobalContractCache; use blockifier::transaction::objects::{ExecutionResourcesTraits, TransactionExecutionInfo}; use blockifier::transaction::transaction_execution::Transaction; -use blockifier::utils::usize_from_u128; +use blockifier::utils::usize_from_u64; use blockifier::versioned_constants::VersionedConstants; use pyo3::prelude::*; use pyo3::types::{PyBytes, PyList}; @@ -93,17 +93,17 @@ impl ThinTransactionExecutionInfo { resources.extend(HashMap::from([ ( abi_constants::L1_GAS_USAGE.to_string(), - usize_from_u128(l1_gas.0) + usize_from_u64(l1_gas.0) .expect("This conversion should not fail as the value is a converted usize."), ), ( abi_constants::BLOB_GAS_USAGE.to_string(), - usize_from_u128(l1_data_gas.0) + usize_from_u64(l1_data_gas.0) .expect("This conversion should not fail as the value is a converted usize."), ), ( abi_constants::L2_GAS_USAGE.to_string(), - usize_from_u128(l2_gas.0) + usize_from_u64(l2_gas.0) .expect("This conversion should not fail as the value is a converted usize."), ), ])); diff --git a/crates/starknet_api/src/block.rs b/crates/starknet_api/src/block.rs index 0669740b7ce..069ab6f53ba 100644 --- a/crates/starknet_api/src/block.rs +++ b/crates/starknet_api/src/block.rs @@ -266,11 +266,12 @@ impl From for PrefixedBytesAsHex<16_usize> { impl GasPrice { pub const fn saturating_mul(self, rhs: GasAmount) -> Fee { - Fee(self.0.saturating_mul(rhs.0)) + #[allow(clippy::as_conversions)] + Fee(self.0.saturating_mul(rhs.0 as u128)) } pub fn checked_mul(self, rhs: GasAmount) -> Option { - self.0.checked_mul(rhs.0).map(Fee) + self.0.checked_mul(u128::from(rhs.0)).map(Fee) } } diff --git a/crates/starknet_api/src/execution_resources.rs b/crates/starknet_api/src/execution_resources.rs index 4457682c624..ce37f24b6c3 100644 --- a/crates/starknet_api/src/execution_resources.rs +++ b/crates/starknet_api/src/execution_resources.rs @@ -21,23 +21,29 @@ use crate::transaction::Fee; Serialize, Deserialize, )] -pub struct GasAmount(pub u128); +pub struct GasAmount(pub u64); macro_rules! impl_from_uint_for_gas_amount { ($($uint:ty),*) => { $( impl From<$uint> for GasAmount { fn from(value: $uint) -> Self { - Self(u128::from(value)) + Self(u64::from(value)) } } )* }; } -impl_from_uint_for_gas_amount!(u8, u16, u32, u64, u128); +impl_from_uint_for_gas_amount!(u8, u16, u32, u64); impl GasAmount { + pub const MAX: Self = Self(u64::MAX); + + pub fn saturating_add(self, rhs: Self) -> Self { + self.0.saturating_add(rhs.0).into() + } + pub const fn saturating_mul(self, rhs: GasPrice) -> Fee { rhs.saturating_mul(self) } diff --git a/crates/starknet_api/src/transaction.rs b/crates/starknet_api/src/transaction.rs index 3f1807b48fe..b8f424aa5ff 100644 --- a/crates/starknet_api/src/transaction.rs +++ b/crates/starknet_api/src/transaction.rs @@ -1,6 +1,5 @@ use std::collections::BTreeMap; use std::fmt::Display; -use std::ops::Div; use std::sync::Arc; use derive_more::{Display, From}; @@ -9,7 +8,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer}; use starknet_types_core::felt::Felt; use strum_macros::EnumIter; -use crate::block::{BlockHash, BlockNumber, GasPrice, NonzeroGasPrice}; +use crate::block::{BlockHash, BlockNumber, NonzeroGasPrice}; use crate::core::{ ChainId, ClassHash, @@ -743,24 +742,30 @@ pub struct RevertedTransactionExecutionStatus { pub struct Fee(pub u128); impl Fee { - pub fn div_ceil(self, rhs: NonzeroGasPrice) -> GasAmount { - let mut result: GasAmount = self / rhs; - if result.0 * rhs.get().0 < self.0 { - result = (result.0 + 1).into(); - } - result - } - pub fn checked_add(self, rhs: Fee) -> Option { self.0.checked_add(rhs.0).map(Fee) } -} -impl Div for Fee { - type Output = GasAmount; + pub fn checked_div_ceil(self, rhs: NonzeroGasPrice) -> Option { + match self.checked_div(rhs) { + Some(value) => Some(if value.nonzero_saturating_mul(rhs) < self { + (value.0 + 1).into() + } else { + value + }), + None => None, + } + } + + pub fn checked_div(self, rhs: NonzeroGasPrice) -> Option { + match u64::try_from(self.0 / rhs.get().0) { + Ok(value) => Some(value.into()), + Err(_) => None, + } + } - fn div(self, rhs: NonzeroGasPrice) -> Self::Output { - (self.0 / GasPrice::from(rhs).0).into() + pub fn saturating_div(self, rhs: NonzeroGasPrice) -> GasAmount { + self.checked_div(rhs).unwrap_or(GasAmount::MAX) } } diff --git a/crates/starknet_api/src/transaction_test.rs b/crates/starknet_api/src/transaction_test.rs index 18982729a3d..c69096bf721 100644 --- a/crates/starknet_api/src/transaction_test.rs +++ b/crates/starknet_api/src/transaction_test.rs @@ -4,9 +4,24 @@ use crate::transaction::Fee; #[test] fn test_fee_div_ceil() { - assert_eq!(GasAmount(1), Fee(1).div_ceil(NonzeroGasPrice::try_from(1_u8).unwrap())); - assert_eq!(GasAmount(0), Fee(0).div_ceil(NonzeroGasPrice::try_from(1_u8).unwrap())); - assert_eq!(GasAmount(1), Fee(1).div_ceil(NonzeroGasPrice::try_from(2_u8).unwrap())); - assert_eq!(GasAmount(9), Fee(27).div_ceil(NonzeroGasPrice::try_from(3_u8).unwrap())); - assert_eq!(GasAmount(10), Fee(28).div_ceil(NonzeroGasPrice::try_from(3_u8).unwrap())); + assert_eq!( + GasAmount(1), + Fee(1).checked_div_ceil(NonzeroGasPrice::try_from(1_u8).unwrap()).unwrap() + ); + assert_eq!( + GasAmount(0), + Fee(0).checked_div_ceil(NonzeroGasPrice::try_from(1_u8).unwrap()).unwrap() + ); + assert_eq!( + GasAmount(1), + Fee(1).checked_div_ceil(NonzeroGasPrice::try_from(2_u8).unwrap()).unwrap() + ); + assert_eq!( + GasAmount(9), + Fee(27).checked_div_ceil(NonzeroGasPrice::try_from(3_u8).unwrap()).unwrap() + ); + assert_eq!( + GasAmount(10), + Fee(28).checked_div_ceil(NonzeroGasPrice::try_from(3_u8).unwrap()).unwrap() + ); } From d9837b181536878c74dcf80d20c61063954e06f1 Mon Sep 17 00:00:00 2001 From: Ayelet Zilber <138376632+ayeletstarkware@users.noreply.github.com> Date: Wed, 9 Oct 2024 13:02:12 +0300 Subject: [PATCH 23/57] refactor(mempool): delete account_nonces tests (#1263) --- crates/mempool/src/mempool_test.rs | 57 ------------------------------ 1 file changed, 57 deletions(-) diff --git a/crates/mempool/src/mempool_test.rs b/crates/mempool/src/mempool_test.rs index 8bdc4ef1870..c5fa98f6961 100644 --- a/crates/mempool/src/mempool_test.rs +++ b/crates/mempool/src/mempool_test.rs @@ -696,60 +696,3 @@ fn test_commit_block_from_different_leader() { .build(); expected_mempool_content.assert_eq(&mempool); } - -// `account_nonces` tests. - -#[rstest] -fn test_account_nonce_does_not_decrease_in_add_tx() { - // Setup. - let input_with_lower_account_nonce = - add_tx_input!(tx_nonce: 0, account_nonce: 0, sender_address: "0x0"); - let account_nonces = [("0x0", 2)]; - let mut mempool = - MempoolContentBuilder::new().with_account_nonces(account_nonces).build_into_mempool(); - - // Test: receives a transaction with a lower account nonce. - add_tx(&mut mempool, &input_with_lower_account_nonce); - - // Assert: the account nonce is not updated. - let expected_mempool_content = - MempoolContentBuilder::new().with_account_nonces(account_nonces).build(); - expected_mempool_content.assert_eq(&mempool); -} - -#[rstest] -fn test_account_nonces_update_in_commit_block() { - // Setup. - let mut mempool = MempoolContentBuilder::new() - .with_pool([tx!(tx_nonce: 2, sender_address: "0x0")]) - .with_account_nonces([("0x0", 0)]) - .build_into_mempool(); - - // Test: update through a commit block. - let nonces = [("0x0", 0)]; - commit_block(&mut mempool, nonces); - - // Assert. - let expected_account_nonces = [("0x0", 1)]; // Account nonce advanced. - let expected_mempool_content = - MempoolContentBuilder::new().with_account_nonces(expected_account_nonces).build(); - expected_mempool_content.assert_eq(&mempool); -} - -#[rstest] -fn test_account_nonce_might_decrease_in_commit_block() { - // Setup. - let mut mempool = MempoolContentBuilder::new() - .with_pool([tx!(tx_nonce: 3, sender_address: "0x0")]) - .with_account_nonces([("0x0", 2)]) - .build_into_mempool(); - - // Test: commits state change of a lower account nonce. - let nonces = [("0x0", 0)]; - commit_block(&mut mempool, nonces); - - // Assert: the account nonce is not updated. - let expected_mempool_content = - MempoolContentBuilder::new().with_account_nonces([("0x0", 1)]).build(); - expected_mempool_content.assert_eq(&mempool); -} From b71bff3159ab6c507ed5088737599cc6168b07ac Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 13:07:02 +0300 Subject: [PATCH 24/57] refactor(starknet_api): gas vector to contain fields of type GasAmount (#1176) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1176) --- crates/committer_cli/src/tests/utils/objects.rs | 8 ++++++-- crates/papyrus_execution/src/objects.rs | 9 +-------- crates/papyrus_protobuf/src/converters/receipt.rs | 12 ++++++++---- crates/papyrus_rpc/src/v0_8/transaction.rs | 5 +++-- .../src/serialization/serializers.rs | 9 +++++---- crates/papyrus_test_utils/src/lib.rs | 9 +++++++-- crates/starknet_api/src/block_hash/test_utils.rs | 8 ++++++-- crates/starknet_api/src/execution_resources.rs | 15 ++++++++++++--- .../src/reader/objects/transaction.rs | 6 +++--- 9 files changed, 51 insertions(+), 30 deletions(-) diff --git a/crates/committer_cli/src/tests/utils/objects.rs b/crates/committer_cli/src/tests/utils/objects.rs index db2b8d31409..0f8a2e239c5 100644 --- a/crates/committer_cli/src/tests/utils/objects.rs +++ b/crates/committer_cli/src/tests/utils/objects.rs @@ -11,7 +11,7 @@ use starknet_api::core::{ Nonce, PatriciaKey, }; -use starknet_api::execution_resources::GasVector; +use starknet_api::execution_resources::{GasAmount, GasVector}; use starknet_api::state::{StorageKey, ThinStateDiff}; use starknet_api::transaction::{ Event, @@ -49,7 +49,11 @@ pub(crate) fn get_transaction_output_for_hash( }, }], execution_status: expected_execution_status, - gas_consumed: GasVector { l1_gas: 0, l2_gas: 0, l1_data_gas: 64 }, + gas_consumed: GasVector { + l1_gas: GasAmount(0), + l2_gas: GasAmount(0), + l1_data_gas: GasAmount(64), + }, messages_sent: vec![MessageToL1 { from_address: ContractAddress(PatriciaKey::from(2_u128)), to_address: EthAddress::try_from(Felt::from_bytes_be_slice(&[1_u8])) diff --git a/crates/papyrus_execution/src/objects.rs b/crates/papyrus_execution/src/objects.rs index b4f8e0b5f09..bbef0bf51ff 100644 --- a/crates/papyrus_execution/src/objects.rs +++ b/crates/papyrus_execution/src/objects.rs @@ -388,14 +388,7 @@ fn vm_resources_to_execution_resources( steps: vm_resources.n_steps as u64, builtin_instance_counter, memory_holes: vm_resources.n_memory_holes as u64, - da_gas_consumed: StarknetApiGasVector { - l1_gas: l1_gas.0.try_into().map_err(|_| ExecutionError::GasConsumedOutOfRange)?, - l2_gas: l2_gas.0.try_into().map_err(|_| ExecutionError::GasConsumedOutOfRange)?, - l1_data_gas: l1_data_gas - .0 - .try_into() - .map_err(|_| ExecutionError::GasConsumedOutOfRange)?, - }, + da_gas_consumed: StarknetApiGasVector { l1_gas, l2_gas, l1_data_gas }, gas_consumed: StarknetApiGasVector::default(), }) } diff --git a/crates/papyrus_protobuf/src/converters/receipt.rs b/crates/papyrus_protobuf/src/converters/receipt.rs index 5aac611d182..052c4bf5e59 100644 --- a/crates/papyrus_protobuf/src/converters/receipt.rs +++ b/crates/papyrus_protobuf/src/converters/receipt.rs @@ -332,7 +332,11 @@ impl TryFrom for ExecutionResources { impl From for GasVector { fn from(value: protobuf::receipt::execution_resources::GasVector) -> Self { - GasVector { l1_gas: value.l1_gas, l1_data_gas: value.l1_data_gas, l2_gas: value.l2_gas } + GasVector { + l1_gas: starknet_api::execution_resources::GasAmount(value.l1_gas), + l1_data_gas: starknet_api::execution_resources::GasAmount(value.l1_data_gas), + l2_gas: starknet_api::execution_resources::GasAmount(value.l2_gas), + } } } @@ -359,9 +363,9 @@ impl From for protobuf::receipt::ExecutionResources { impl From for protobuf::receipt::execution_resources::GasVector { fn from(value: GasVector) -> Self { protobuf::receipt::execution_resources::GasVector { - l1_gas: value.l1_gas, - l1_data_gas: value.l1_data_gas, - l2_gas: value.l2_gas, + l1_gas: value.l1_gas.0, + l1_data_gas: value.l1_data_gas.0, + l2_gas: value.l2_gas.0, } } } diff --git a/crates/papyrus_rpc/src/v0_8/transaction.rs b/crates/papyrus_rpc/src/v0_8/transaction.rs index c246ad5bb7b..542dec8de6b 100644 --- a/crates/papyrus_rpc/src/v0_8/transaction.rs +++ b/crates/papyrus_rpc/src/v0_8/transaction.rs @@ -26,6 +26,7 @@ use starknet_api::core::{ Nonce, }; use starknet_api::data_availability::DataAvailabilityMode; +use starknet_api::execution_resources::GasAmount; use starknet_api::serde_utils::bytes_from_hex_str; use starknet_api::transaction::{ AccountDeploymentData, @@ -902,8 +903,8 @@ pub struct ComputationResources { #[derive(Debug, Default, Clone, Eq, Hash, PartialEq, Deserialize, Serialize, PartialOrd, Ord)] pub struct DataAvailabilityResources { - pub l1_gas: u64, - pub l1_data_gas: u64, + pub l1_gas: GasAmount, + pub l1_data_gas: GasAmount, } impl Add for ExecutionResources { diff --git a/crates/papyrus_storage/src/serialization/serializers.rs b/crates/papyrus_storage/src/serialization/serializers.rs index d51ab4ca312..815e7f7d7e0 100644 --- a/crates/papyrus_storage/src/serialization/serializers.rs +++ b/crates/papyrus_storage/src/serialization/serializers.rs @@ -64,7 +64,7 @@ use starknet_api::deprecated_contract_class::{ StructType, TypedParameter, }; -use starknet_api::execution_resources::{Builtin, ExecutionResources, GasVector}; +use starknet_api::execution_resources::{Builtin, ExecutionResources, GasAmount, GasVector}; use starknet_api::hash::{PoseidonHash, StarkHash}; use starknet_api::state::{ ContractClass, @@ -284,14 +284,15 @@ auto_storage_serde! { View = 0, } pub struct GasPrice(pub u128); + pub struct GasAmount(pub u64); pub struct GasPricePerToken { pub price_in_fri: GasPrice, pub price_in_wei: GasPrice, } pub struct GasVector { - pub l1_gas: u64, - pub l1_data_gas: u64, - pub l2_gas: u64, + pub l1_gas: GasAmount, + pub l1_data_gas: GasAmount, + pub l2_gas: GasAmount, } pub struct GlobalRoot(pub StarkHash); pub struct H160(pub [u8; 20]); diff --git a/crates/papyrus_test_utils/src/lib.rs b/crates/papyrus_test_utils/src/lib.rs index 9347e6123c9..a3145d67c90 100644 --- a/crates/papyrus_test_utils/src/lib.rs +++ b/crates/papyrus_test_utils/src/lib.rs @@ -85,7 +85,7 @@ use starknet_api::deprecated_contract_class::{ StructType, TypedParameter, }; -use starknet_api::execution_resources::{Builtin, ExecutionResources, GasVector}; +use starknet_api::execution_resources::{Builtin, ExecutionResources, GasAmount, GasVector}; use starknet_api::felt; use starknet_api::hash::{PoseidonHash, StarkHash}; use starknet_api::rpc_transaction::{ @@ -637,6 +637,7 @@ auto_impl_get_test_instance! { pub enum FunctionType { Function = 0, } + pub struct GasAmount(pub u64); pub struct GasPrice(pub u128); pub struct GasPricePerToken { pub price_in_fri: GasPrice, @@ -1130,7 +1131,11 @@ impl GetTestInstance for ExecutionResources { impl GetTestInstance for GasVector { fn get_test_instance(rng: &mut ChaCha8Rng) -> Self { - Self { l1_gas: rng.next_u64(), l2_gas: rng.next_u64(), l1_data_gas: rng.next_u64() } + Self { + l1_gas: GasAmount(rng.next_u64()), + l2_gas: GasAmount(rng.next_u64()), + l1_data_gas: GasAmount(rng.next_u64()), + } } } diff --git a/crates/starknet_api/src/block_hash/test_utils.rs b/crates/starknet_api/src/block_hash/test_utils.rs index ddf7786dbcc..08bd00af94b 100644 --- a/crates/starknet_api/src/block_hash/test_utils.rs +++ b/crates/starknet_api/src/block_hash/test_utils.rs @@ -4,7 +4,7 @@ use starknet_types_core::felt::Felt; use super::block_hash_calculator::TransactionOutputForHash; use crate::core::{ClassHash, CompiledClassHash, ContractAddress, EthAddress, Nonce}; -use crate::execution_resources::GasVector; +use crate::execution_resources::{GasAmount, GasVector}; use crate::state::ThinStateDiff; use crate::transaction::{ Fee, @@ -24,7 +24,11 @@ pub(crate) fn get_transaction_output() -> TransactionOutputForHash { messages_sent: vec![generate_message_to_l1(34), generate_message_to_l1(56)], events: vec![], execution_status, - gas_consumed: GasVector { l1_gas: 16580, l2_gas: 0, l1_data_gas: 32 }, + gas_consumed: GasVector { + l1_gas: GasAmount(16580), + l2_gas: GasAmount(0), + l1_data_gas: GasAmount(32), + }, } } diff --git a/crates/starknet_api/src/execution_resources.rs b/crates/starknet_api/src/execution_resources.rs index ce37f24b6c3..43a0352ebc9 100644 --- a/crates/starknet_api/src/execution_resources.rs +++ b/crates/starknet_api/src/execution_resources.rs @@ -1,6 +1,7 @@ use std::collections::HashMap; use serde::{Deserialize, Serialize}; +use starknet_types_core::felt::Felt; use strum_macros::EnumIter; use crate::block::{GasPrice, NonzeroGasPrice}; @@ -18,11 +19,19 @@ use crate::transaction::Fee; Eq, PartialEq, PartialOrd, + Ord, Serialize, Deserialize, + Hash, )] pub struct GasAmount(pub u64); +impl From for Felt { + fn from(gas_amount: GasAmount) -> Self { + Self::from(gas_amount.0) + } +} + macro_rules! impl_from_uint_for_gas_amount { ($($uint:ty),*) => { $( @@ -63,10 +72,10 @@ impl GasAmount { #[derive(Debug, Default, Deserialize, Serialize, Clone, Eq, PartialEq)] pub struct GasVector { - pub l1_gas: u64, - pub l1_data_gas: u64, + pub l1_gas: GasAmount, + pub l1_data_gas: GasAmount, #[serde(default)] - pub l2_gas: u64, + pub l2_gas: GasAmount, } /// The execution resources used by a transaction. diff --git a/crates/starknet_client/src/reader/objects/transaction.rs b/crates/starknet_client/src/reader/objects/transaction.rs index 179fb618267..aa1cdd5f373 100644 --- a/crates/starknet_client/src/reader/objects/transaction.rs +++ b/crates/starknet_client/src/reader/objects/transaction.rs @@ -14,7 +14,7 @@ use starknet_api::core::{ EthAddress, Nonce, }; -use starknet_api::execution_resources::GasVector; +use starknet_api::execution_resources::{GasAmount, GasVector}; use starknet_api::hash::StarkHash; use starknet_api::transaction::{ AccountDeploymentData, @@ -716,8 +716,8 @@ impl From for starknet_api::execution_resources::ExecutionRe None => GasVector { // It's hardcoded that this field is 0 for pre-v0.13.2 blocks (this field is // only used in calculating the receipt hash) - l1_gas: 0, - l2_gas: 0, + l1_gas: GasAmount(0), + l2_gas: GasAmount(0), l1_data_gas: da_gas_consumed.l1_data_gas, }, }, From f529dd806f0561b02ce4c9b653c401470ba84395 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 13:23:29 +0300 Subject: [PATCH 25/57] refactor(blockifier): indirection in GasPrices struct (#1177) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1177) --- crates/blockifier/src/blockifier/block.rs | 52 ++++++++----------- crates/blockifier/src/fee/fee_utils.rs | 2 +- .../src/transaction/account_transaction.rs | 6 +-- 3 files changed, 25 insertions(+), 35 deletions(-) diff --git a/crates/blockifier/src/blockifier/block.rs b/crates/blockifier/src/blockifier/block.rs index 7703ce12685..385557807ac 100644 --- a/crates/blockifier/src/blockifier/block.rs +++ b/crates/blockifier/src/blockifier/block.rs @@ -28,15 +28,11 @@ pub struct BlockInfo { #[derive(Clone, Debug)] pub struct GasPrices { - eth_l1_gas_price: NonzeroGasPrice, // In wei. - strk_l1_gas_price: NonzeroGasPrice, // In fri. - eth_l1_data_gas_price: NonzeroGasPrice, // In wei. - strk_l1_data_gas_price: NonzeroGasPrice, // In fri. - eth_l2_gas_price: NonzeroGasPrice, // In wei. - strk_l2_gas_price: NonzeroGasPrice, // In fri. + eth_gas_prices: GasPricesForFeeType, // In wei. + strk_gas_prices: GasPricesForFeeType, // In fri. } -#[derive(Debug)] +#[derive(Clone, Debug)] pub struct GasPricesForFeeType { pub l1_gas_price: NonzeroGasPrice, pub l1_data_gas_price: NonzeroGasPrice, @@ -72,42 +68,36 @@ impl GasPrices { ) } - GasPrices { - eth_l1_gas_price, - strk_l1_gas_price, - eth_l1_data_gas_price, - strk_l1_data_gas_price, - eth_l2_gas_price, - strk_l2_gas_price, + Self { + eth_gas_prices: GasPricesForFeeType { + l1_gas_price: eth_l1_gas_price, + l1_data_gas_price: eth_l1_data_gas_price, + l2_gas_price: eth_l2_gas_price, + }, + strk_gas_prices: GasPricesForFeeType { + l1_gas_price: strk_l1_gas_price, + l1_data_gas_price: strk_l1_data_gas_price, + l2_gas_price: strk_l2_gas_price, + }, } } pub fn get_l1_gas_price_by_fee_type(&self, fee_type: &FeeType) -> NonzeroGasPrice { - match fee_type { - FeeType::Strk => self.strk_l1_gas_price, - FeeType::Eth => self.eth_l1_gas_price, - } + self.get_gas_prices_by_fee_type(fee_type).l1_gas_price } pub fn get_l1_data_gas_price_by_fee_type(&self, fee_type: &FeeType) -> NonzeroGasPrice { - match fee_type { - FeeType::Strk => self.strk_l1_data_gas_price, - FeeType::Eth => self.eth_l1_data_gas_price, - } + self.get_gas_prices_by_fee_type(fee_type).l1_data_gas_price } pub fn get_l2_gas_price_by_fee_type(&self, fee_type: &FeeType) -> NonzeroGasPrice { - match fee_type { - FeeType::Strk => self.strk_l2_gas_price, - FeeType::Eth => self.eth_l2_gas_price, - } + self.get_gas_prices_by_fee_type(fee_type).l2_gas_price } - pub fn get_gas_prices_by_fee_type(&self, fee_type: &FeeType) -> GasPricesForFeeType { - GasPricesForFeeType { - l1_gas_price: self.get_l1_gas_price_by_fee_type(fee_type), - l1_data_gas_price: self.get_l1_data_gas_price_by_fee_type(fee_type), - l2_gas_price: self.get_l2_gas_price_by_fee_type(fee_type), + pub fn get_gas_prices_by_fee_type(&self, fee_type: &FeeType) -> &GasPricesForFeeType { + match fee_type { + FeeType::Strk => &self.strk_gas_prices, + FeeType::Eth => &self.eth_gas_prices, } } } diff --git a/crates/blockifier/src/fee/fee_utils.rs b/crates/blockifier/src/fee/fee_utils.rs index e7d34530c65..04ed53f58e7 100644 --- a/crates/blockifier/src/fee/fee_utils.rs +++ b/crates/blockifier/src/fee/fee_utils.rs @@ -79,7 +79,7 @@ pub fn get_fee_by_gas_vector( gas_vector: GasVector, fee_type: &FeeType, ) -> Fee { - gas_vector.saturated_cost(&block_info.gas_prices.get_gas_prices_by_fee_type(fee_type)) + gas_vector.saturated_cost(block_info.gas_prices.get_gas_prices_by_fee_type(fee_type)) } /// Returns the current fee balance and a boolean indicating whether the balance covers the fee. diff --git a/crates/blockifier/src/transaction/account_transaction.rs b/crates/blockifier/src/transaction/account_transaction.rs index 7a8fb858d85..a0c8ea6e36b 100644 --- a/crates/blockifier/src/transaction/account_transaction.rs +++ b/crates/blockifier/src/transaction/account_transaction.rs @@ -335,19 +335,19 @@ impl AccountTransaction { L1Gas, l1_gas_resource_bounds, minimal_gas_amount_vector.l1_gas, - l1_gas_price, + *l1_gas_price, ), ( L1DataGas, l1_data_gas_resource_bounds, minimal_gas_amount_vector.l1_data_gas, - l1_data_gas_price, + *l1_data_gas_price, ), ( L2Gas, l2_gas_resource_bounds, minimal_gas_amount_vector.l2_gas, - l2_gas_price, + *l2_gas_price, ), ] } From ff44c571b89b746fa00288a5d1e826dc81a217c7 Mon Sep 17 00:00:00 2001 From: Elin Date: Wed, 9 Oct 2024 13:32:03 +0300 Subject: [PATCH 26/57] feat(mempool): move transaction deletions from get_txs to commit_block (#1238) --- crates/mempool/src/mempool.rs | 46 +++++++++------ crates/mempool/src/mempool_test.rs | 70 ++++++++++++++++------- crates/mempool/src/test_utils.rs | 16 +++++- crates/mempool/src/transaction_pool.rs | 8 +-- crates/mempool/tests/flow_test.rs | 31 ++++++---- crates/mempool_types/src/mempool_types.rs | 4 +- 6 files changed, 119 insertions(+), 56 deletions(-) diff --git a/crates/mempool/src/mempool.rs b/crates/mempool/src/mempool.rs index baa254255d7..806caf13901 100644 --- a/crates/mempool/src/mempool.rs +++ b/crates/mempool/src/mempool.rs @@ -47,9 +47,7 @@ impl Mempool { /// Retrieves up to `n_txs` transactions with the highest priority from the mempool. /// Transactions are guaranteed to be unique across calls until the block in-progress is /// created. - // TODO: the last part about commit_block is incorrect if we delete txs in get_txs and then push - // back. TODO: Consider renaming to `pop_txs` to be more consistent with the standard - // library. + // TODO: Consider renaming to `pop_txs` to be more consistent with the standard library. pub fn get_txs(&mut self, n_txs: usize) -> MempoolResult> { let mut eligible_tx_references: Vec = Vec::with_capacity(n_txs); let mut n_remaining_txs = n_txs; @@ -61,20 +59,20 @@ impl Mempool { eligible_tx_references.extend(chunk); } - let mut eligible_txs: Vec = Vec::with_capacity(n_txs); - for tx_ref in &eligible_tx_references { - let tx = self.tx_pool.remove(tx_ref.tx_hash)?; - // TODO(clean_account_nonces): remove address from nonce table after a block cycle / - // TTL. - eligible_txs.push(tx); - } - // Update the mempool state with the given transactions' nonces. for tx_ref in &eligible_tx_references { self.mempool_state.insert(tx_ref.sender_address, tx_ref.nonce); } - Ok(eligible_txs) + Ok(eligible_tx_references + .iter() + .map(|tx_ref| { + self.tx_pool + .get_by_tx_hash(tx_ref.tx_hash) + .expect("Transaction hash from queue must appear in pool.") + }) + .cloned() // Soft-delete: return without deleting from mempool. + .collect()) } /// Adds a new transaction to the mempool. @@ -100,8 +98,6 @@ impl Mempool { /// Update the mempool's internal state according to the committed block (resolves nonce gaps, /// updates account balances). - // TODO: the part about resolving nonce gaps is incorrect if we delete txs in get_txs and then - // push back. pub fn commit_block(&mut self, args: CommitBlockArgs) -> MempoolResult<()> { for (&address, &nonce) in &args.nonces { let next_nonce = nonce.try_increment().map_err(|_| MempoolError::FeltOutOfRange)?; @@ -109,11 +105,27 @@ impl Mempool { self.align_to_account_state(account_state); } + // Hard-delete: finally, remove committed transactions from the mempool. + for tx_hash in args.tx_hashes { + let Ok(_tx) = self.tx_pool.remove(tx_hash) else { + continue; // Transaction hash unknown to mempool, from a different node. + }; + + // TODO(clean_account_nonces): remove address from nonce table after a block cycle / + // TTL. + } + // Rewind nonces of addresses that were not included in block. - let addresses_not_included_in_block = + let known_addresses_not_included_in_block = self.mempool_state.keys().filter(|&key| !args.nonces.contains_key(key)); - for address in addresses_not_included_in_block { - self.tx_queue.remove(*address); + for address in known_addresses_not_included_in_block { + // Account nonce is the minimal nonce of this address: it was proposed but not included. + let tx_reference = self + .tx_pool + .account_txs_sorted_by_nonce(*address) + .next() + .expect("Address {address} should appear in transaction pool."); + self.tx_queue.insert(*tx_reference); } // Commit: clear block creation staged state. diff --git a/crates/mempool/src/mempool_test.rs b/crates/mempool/src/mempool_test.rs index c5fa98f6961..9eb0556735e 100644 --- a/crates/mempool/src/mempool_test.rs +++ b/crates/mempool/src/mempool_test.rs @@ -191,7 +191,7 @@ fn test_get_txs_returns_by_priority_order(#[case] n_requested_txs: usize) { } #[rstest] -fn test_get_txs_removes_returned_txs_from_pool() { +fn test_get_txs_does_not_remove_returned_txs_from_pool() { // Setup. let tx_nonce_0 = tx!(tx_hash: 1, sender_address: "0x0", tx_nonce: 0); let tx_nonce_1 = tx!(tx_hash: 2, sender_address: "0x0", tx_nonce: 1); @@ -207,7 +207,7 @@ fn test_get_txs_removes_returned_txs_from_pool() { // Test and assert: all transactions are returned. get_txs_and_assert_expected(&mut mempool, 3, &pool_txs); let expected_mempool_content = - MempoolContentBuilder::new().with_pool([]).with_priority_queue([]).build(); + MempoolContentBuilder::new().with_pool(pool_txs).with_priority_queue([]).build(); expected_mempool_content.assert_eq(&mempool); } @@ -614,17 +614,25 @@ fn test_add_tx_fills_nonce_gap(mut mempool: Mempool) { // `commit_block` tests. #[rstest] -fn test_commit_block_includes_all_txs() { +fn test_commit_block_includes_all_proposed_txs() { // Setup. - let tx_address_0_nonce_4 = tx!(tx_hash: 1, sender_address: "0x0", tx_nonce: 4); - let tx_address_0_nonce_5 = tx!(tx_hash: 2, sender_address: "0x0", tx_nonce: 5); - let tx_address_1_nonce_3 = tx!(tx_hash: 3, sender_address: "0x1", tx_nonce: 3); - let tx_address_2_nonce_1 = tx!(tx_hash: 4, sender_address: "0x2", tx_nonce: 1); + let tx_address_0_nonce_3 = tx!(tx_hash: 1, sender_address: "0x0", tx_nonce: 3); + let tx_address_0_nonce_4 = tx!(tx_hash: 2, sender_address: "0x0", tx_nonce: 4); + let tx_address_0_nonce_5 = tx!(tx_hash: 3, sender_address: "0x0", tx_nonce: 5); + let tx_address_1_nonce_2 = tx!(tx_hash: 4, sender_address: "0x1", tx_nonce: 2); + let tx_address_1_nonce_3 = tx!(tx_hash: 5, sender_address: "0x1", tx_nonce: 3); + let tx_address_2_nonce_1 = tx!(tx_hash: 6, sender_address: "0x2", tx_nonce: 1); let queue_txs = [&tx_address_0_nonce_4, &tx_address_1_nonce_3, &tx_address_2_nonce_1] .map(TransactionReference::new); - let pool_txs = - [tx_address_0_nonce_4, tx_address_0_nonce_5, tx_address_1_nonce_3, tx_address_2_nonce_1]; + let pool_txs = [ + tx_address_0_nonce_3, + tx_address_0_nonce_4.clone(), + tx_address_0_nonce_5.clone(), + tx_address_1_nonce_2, + tx_address_1_nonce_3.clone(), + tx_address_2_nonce_1.clone(), + ]; let mut mempool = MempoolContentBuilder::new() .with_pool(pool_txs.clone()) .with_priority_queue(queue_txs) @@ -632,9 +640,12 @@ fn test_commit_block_includes_all_txs() { // Test. let nonces = [("0x0", 3), ("0x1", 2)]; - commit_block(&mut mempool, nonces); + let tx_hashes = [1, 4]; + commit_block(&mut mempool, nonces, tx_hashes); // Assert. + let pool_txs = + [tx_address_0_nonce_4, tx_address_0_nonce_5, tx_address_1_nonce_3, tx_address_2_nonce_1]; let expected_mempool_content = MempoolContentBuilder::new().with_pool(pool_txs).with_priority_queue(queue_txs).build(); expected_mempool_content.assert_eq(&mempool); @@ -643,21 +654,32 @@ fn test_commit_block_includes_all_txs() { #[rstest] fn test_commit_block_rewinds_queued_nonce() { // Setup. - let tx_address_0_nonce_5 = tx!(tx_hash: 2, sender_address: "0x0", tx_nonce: 5); + let tx_address_0_nonce_3 = tx!(tx_hash: 1, sender_address: "0x0", tx_nonce: 3); + let tx_address_0_nonce_4 = tx!(tx_hash: 2, sender_address: "0x0", tx_nonce: 4); + let tx_address_0_nonce_5 = tx!(tx_hash: 3, sender_address: "0x0", tx_nonce: 5); + let tx_address_1_nonce_1 = tx!(tx_hash: 4, sender_address: "0x1", tx_nonce: 1); - let queued_txs = [TransactionReference::new(&tx_address_0_nonce_5)]; - let pool_txs = [tx_address_0_nonce_5]; + let queued_txs = [&tx_address_0_nonce_5, &tx_address_1_nonce_1].map(TransactionReference::new); + let pool_txs = [ + tx_address_0_nonce_3, + tx_address_0_nonce_4.clone(), + tx_address_0_nonce_5, + tx_address_1_nonce_1, + ]; let mut mempool = MempoolContentBuilder::new() .with_pool(pool_txs) .with_priority_queue(queued_txs) .build_into_mempool(); // Test. - let nonces = [("0x0", 3), ("0x1", 3)]; - commit_block(&mut mempool, nonces); + let nonces = [("0x0", 3), ("0x1", 1)]; + let tx_hashes = [1, 4]; + commit_block(&mut mempool, nonces, tx_hashes); // Assert. - let expected_mempool_content = MempoolContentBuilder::new().with_priority_queue([]).build(); + let expected_queue_txs = [TransactionReference::new(&tx_address_0_nonce_4)]; + let expected_mempool_content = + MempoolContentBuilder::new().with_priority_queue(expected_queue_txs).build(); expected_mempool_content.assert_eq(&mempool); } @@ -674,7 +696,7 @@ fn test_commit_block_from_different_leader() { tx_address_0_nonce_3, tx_address_0_nonce_5, tx_address_0_nonce_6.clone(), - tx_address_1_nonce_2, + tx_address_1_nonce_2.clone(), ]; let mut mempool = MempoolContentBuilder::new() .with_pool(pool_txs) @@ -684,15 +706,21 @@ fn test_commit_block_from_different_leader() { // Test. let nonces = [ ("0x0", 5), - // A hole, missing nonce 1 for address "0x1". - ("0x1", 0), + ("0x1", 0), // A hole, missing nonce 1 for address "0x1". ("0x2", 1), ]; - commit_block(&mut mempool, nonces); + let tx_hashes = [ + 1, 2, // Hashes known to mempool. + 5, 6, // Hashes unknown to mempool, from a different node. + ]; + commit_block(&mut mempool, nonces, tx_hashes); // Assert. + let expected_queue_txs = [TransactionReference::new(&tx_address_0_nonce_6)]; + let expected_pool_txs = [tx_address_0_nonce_6, tx_address_1_nonce_2]; let expected_mempool_content = MempoolContentBuilder::new() - .with_priority_queue([TransactionReference::new(&tx_address_0_nonce_6)]) + .with_pool(expected_pool_txs) + .with_priority_queue(expected_queue_txs) .build(); expected_mempool_content.assert_eq(&mempool); } diff --git a/crates/mempool/src/test_utils.rs b/crates/mempool/src/test_utils.rs index 76e719b95f5..1ec37875c0f 100644 --- a/crates/mempool/src/test_utils.rs +++ b/crates/mempool/src/test_utils.rs @@ -1,8 +1,9 @@ -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use pretty_assertions::assert_eq; use starknet_api::core::{ContractAddress, PatriciaKey}; use starknet_api::executable_transaction::Transaction; +use starknet_api::transaction::TransactionHash; use starknet_api::{contract_address, felt, nonce, patricia_key}; use starknet_mempool_types::errors::MempoolError; use starknet_mempool_types::mempool_types::{AddTransactionArgs, CommitBlockArgs}; @@ -39,6 +40,9 @@ macro_rules! tx { (tx_nonce: $tx_nonce:expr, sender_address: $sender_address:expr) => { tx!(tip: 0, tx_hash: 0, sender_address: $sender_address, tx_nonce: $tx_nonce) }; + (tx_hash: $tx_hash:expr, tx_nonce: $tx_nonce:expr, sender_address: $sender_address:expr) => { + tx!(tip: 0, tx_hash: $tx_hash, sender_address: $sender_address, tx_nonce: $tx_nonce) + }; (tx_nonce: $tx_nonce:expr) => { tx!(tip: 0, tx_hash: 0, sender_address: "0x0", tx_nonce: $tx_nonce) }; @@ -98,11 +102,17 @@ pub fn add_tx_expect_error( } #[track_caller] -pub fn commit_block(mempool: &mut Mempool, nonces: impl IntoIterator) { +pub fn commit_block( + mempool: &mut Mempool, + nonces: impl IntoIterator, + tx_hashes: impl IntoIterator, +) { let nonces = HashMap::from_iter( nonces.into_iter().map(|(address, nonce)| (contract_address!(address), nonce!(nonce))), ); - let args = CommitBlockArgs { nonces }; + let tx_hashes = + HashSet::from_iter(tx_hashes.into_iter().map(|tx_hash| TransactionHash(felt!(tx_hash)))); + let args = CommitBlockArgs { nonces, tx_hashes }; assert_eq!(mempool.commit_block(args), Ok(())); } diff --git a/crates/mempool/src/transaction_pool.rs b/crates/mempool/src/transaction_pool.rs index 082df4eb287..78b31f11853 100644 --- a/crates/mempool/src/transaction_pool.rs +++ b/crates/mempool/src/transaction_pool.rs @@ -83,14 +83,14 @@ impl TransactionPool { } } - pub fn _account_txs_sorted_by_nonce( + pub fn account_txs_sorted_by_nonce( &self, address: ContractAddress, ) -> impl Iterator { - self.txs_by_account._account_txs_sorted_by_nonce(address) + self.txs_by_account.account_txs_sorted_by_nonce(address) } - pub fn _get_by_tx_hash(&self, tx_hash: TransactionHash) -> MempoolResult<&Transaction> { + pub fn get_by_tx_hash(&self, tx_hash: TransactionHash) -> MempoolResult<&Transaction> { self.tx_pool.get(&tx_hash).ok_or(MempoolError::TransactionNotFound { tx_hash }) } @@ -143,7 +143,7 @@ impl AccountTransactionIndex { self.0.get(&address)?.get(&nonce) } - fn _account_txs_sorted_by_nonce( + fn account_txs_sorted_by_nonce( &self, address: ContractAddress, ) -> impl Iterator { diff --git a/crates/mempool/tests/flow_test.rs b/crates/mempool/tests/flow_test.rs index 1310440f899..e3dce8ca2f0 100644 --- a/crates/mempool/tests/flow_test.rs +++ b/crates/mempool/tests/flow_test.rs @@ -90,20 +90,25 @@ fn test_add_same_nonce_tx_after_previous_not_included_in_block(mut mempool: Memp get_txs_and_assert_expected( &mut mempool, 2, - &[tx_nonce_3_account_nonce_3.tx, tx_nonce_4_account_nonce_3.tx], + &[tx_nonce_3_account_nonce_3.tx, tx_nonce_4_account_nonce_3.tx.clone()], ); let nonces = [("0x0", 3)]; // Transaction with nonce 4 is not included in the block. - commit_block(&mut mempool, nonces); + let tx_hashes = [1]; + commit_block(&mut mempool, nonces, tx_hashes); let tx_nonce_4_account_nonce_4 = - add_tx_input!(tx_hash: 2, sender_address: "0x0", tx_nonce: 4, account_nonce: 4); - add_tx(&mut mempool, &tx_nonce_4_account_nonce_4); + add_tx_input!(tx_hash: 4, sender_address: "0x0", tx_nonce: 4, account_nonce: 4); + add_tx_expect_error( + &mut mempool, + &tx_nonce_4_account_nonce_4, + MempoolError::DuplicateNonce { address: contract_address!("0x0"), nonce: nonce!(4) }, + ); get_txs_and_assert_expected( &mut mempool, 2, - &[tx_nonce_4_account_nonce_4.tx, tx_nonce_5_account_nonce_3.tx], + &[tx_nonce_4_account_nonce_3.tx, tx_nonce_5_account_nonce_3.tx], ); } @@ -141,19 +146,24 @@ fn test_commit_block_includes_proposed_txs_subset(mut mempool: Mempool) { get_txs_and_assert_expected( &mut mempool, 2, - &[tx_address_2_nonce_2.tx, tx_address_1_nonce_0.tx], + &[tx_address_2_nonce_2.tx.clone(), tx_address_1_nonce_0.tx], ); get_txs_and_assert_expected( &mut mempool, 2, - &[tx_address_1_nonce_1.tx, tx_address_0_nonce_3.tx], + &[tx_address_1_nonce_1.tx.clone(), tx_address_0_nonce_3.tx], ); // Not included in block: address "0x2" nonce 2, address "0x1" nonce 1. let nonces = [("0x0", 3), ("0x1", 0)]; - commit_block(&mut mempool, nonces); + let tx_hashes = [1, 4]; + commit_block(&mut mempool, nonces, tx_hashes); - get_txs_and_assert_expected(&mut mempool, 2, &[]); + get_txs_and_assert_expected( + &mut mempool, + 2, + &[tx_address_2_nonce_2.tx, tx_address_1_nonce_1.tx], + ); } #[rstest] @@ -172,7 +182,8 @@ fn test_flow_commit_block_fills_nonce_gap(mut mempool: Mempool) { get_txs_and_assert_expected(&mut mempool, 2, &[tx_nonce_3_account_nonce_3.tx]); let nonces = [("0x0", 4)]; - commit_block(&mut mempool, nonces); + let tx_hashes = [1, 3]; + commit_block(&mut mempool, nonces, tx_hashes); // Assert: hole was indeed closed. let tx_nonce_4_account_nonce_4 = diff --git a/crates/mempool_types/src/mempool_types.rs b/crates/mempool_types/src/mempool_types.rs index 49d67790051..4a46adbf793 100644 --- a/crates/mempool_types/src/mempool_types.rs +++ b/crates/mempool_types/src/mempool_types.rs @@ -1,8 +1,9 @@ -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use serde::{Deserialize, Serialize}; use starknet_api::core::{ContractAddress, Nonce}; use starknet_api::executable_transaction::Transaction; +use starknet_api::transaction::TransactionHash; use crate::errors::MempoolError; @@ -22,6 +23,7 @@ pub struct AddTransactionArgs { #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] pub struct CommitBlockArgs { pub nonces: HashMap, + pub tx_hashes: HashSet, } pub type MempoolResult = Result; From 2ce2383b2b379f0ec8720d438ef4973d9a5a3e0f Mon Sep 17 00:00:00 2001 From: Asmaa Magdoub Date: Sun, 6 Oct 2024 14:29:28 +0300 Subject: [PATCH 27/57] refactor(consensus): add past_round_upons as in the paper --- .../papyrus_consensus/src/state_machine.rs | 97 +++++++++++++++++-- 1 file changed, 87 insertions(+), 10 deletions(-) diff --git a/crates/sequencing/papyrus_consensus/src/state_machine.rs b/crates/sequencing/papyrus_consensus/src/state_machine.rs index c6551c12d2d..67a6ba8141d 100644 --- a/crates/sequencing/papyrus_consensus/src/state_machine.rs +++ b/crates/sequencing/papyrus_consensus/src/state_machine.rs @@ -10,7 +10,7 @@ mod state_machine_test; use std::collections::{HashMap, VecDeque}; use starknet_api::block::BlockHash; -use tracing::trace; +use tracing::{error, trace}; use crate::types::{ProposalContentId, Round, ValidatorId}; @@ -56,7 +56,8 @@ pub struct StateMachine { round: Round, step: Step, quorum: u32, - proposals: HashMap>, + // {round: (block_hash, valid_round)} + proposals: HashMap, Option)>, // {round: {block_hash: vote_count} prevotes: HashMap, u32>>, precommits: HashMap, u32>>, @@ -188,8 +189,8 @@ impl StateMachine { StateMachineEvent::GetProposal(block_hash, round) => { self.handle_get_proposal(block_hash, round) } - StateMachineEvent::Proposal(block_hash, round, _) => { - self.handle_proposal(block_hash, round, leader_fn) + StateMachineEvent::Proposal(block_hash, round, valid_round) => { + self.handle_proposal(block_hash, round, valid_round, leader_fn) } StateMachineEvent::Prevote(block_hash, round) => { self.handle_prevote(block_hash, round, leader_fn) @@ -228,13 +229,17 @@ impl StateMachine { &mut self, block_hash: Option, round: u32, + valid_round: Option, leader_fn: &LeaderFn, ) -> VecDeque where LeaderFn: Fn(Round) -> ValidatorId, { - let old = self.proposals.insert(round, block_hash); + let old = self.proposals.insert(round, (block_hash, valid_round)); assert!(old.is_none(), "SHC should handle conflicts & replays"); + if round < self.round { + return self.past_round_upons(round); + } if round != self.round { return VecDeque::new(); } @@ -280,7 +285,9 @@ impl StateMachine { let prevote_count = self.prevotes.entry(round).or_default().entry(block_hash).or_insert(0); // TODO(matan): Use variable weight. *prevote_count += 1; - + if round < self.round { + return self.past_round_upons(round); + } if self.step != Step::Prevote || round != self.round { return VecDeque::new(); } @@ -309,7 +316,9 @@ impl StateMachine { self.precommits.entry(round).or_default().entry(block_hash).or_insert(0); // TODO(matan): Use variable weight. *precommit_count += 1; - + if round < self.round { + return self.past_round_upons(round); + } self.check_precommit_quorum(round, leader_fn) } @@ -368,7 +377,7 @@ impl StateMachine { output.append(&mut self.send_precommit(*block_hash, round, leader_fn)); return output; } - let Some(proposed_value) = self.proposals.get(&round) else { + let Some((proposed_value, _)) = self.proposals.get(&round) else { return output; }; if proposed_value != block_hash { @@ -413,7 +422,7 @@ impl StateMachine { return output; } } - let Some(proposed_value) = self.proposals.get(&round) else { + let Some((proposed_value, _)) = self.proposals.get(&round) else { return output; }; if proposed_value != block_hash { @@ -468,11 +477,79 @@ impl StateMachine { } } } - let Some(proposal) = self.proposals.get(&round) else { + let Some((proposal, _)) = self.proposals.get(&round) else { return VecDeque::from([StateMachineEvent::TimeoutPropose(round)]); }; self.process_proposal(*proposal, round, leader_fn) } + + fn past_round_upons(&mut self, round: u32) -> VecDeque { + let mut output = VecDeque::new(); + output.append(&mut self.upon_reproposal()); + output.append(&mut self.upon_decision(round)); + output + } + + // LOC 28 in the paper. + fn upon_reproposal(&mut self) -> VecDeque { + if self.step != Step::Propose { + return VecDeque::new(); + } + let Some((block_hash, valid_round)) = self.proposals.get(&self.round) else { + return VecDeque::new(); + }; + let Some(valid_round) = valid_round else { + return VecDeque::new(); + }; + if valid_round >= &self.round { + return VecDeque::new(); + } + let Some(round_prevotes) = self.prevotes.get(valid_round) else { + return VecDeque::new(); + }; + let Some(count) = round_prevotes.get(block_hash) else { return VecDeque::new() }; + + if count < &self.quorum { + return VecDeque::new(); + } + let output = if block_hash.is_some_and(|v| { + self.locked_value.is_none() + || self.locked_value.is_some_and(|(locked_value, locked_round)| { + locked_round <= *valid_round || locked_value == v + }) + }) { + VecDeque::from([StateMachineEvent::Prevote(*block_hash, self.round)]) + } else { + VecDeque::from([StateMachineEvent::Prevote(None, self.round)]) + }; + + self.step = Step::Prevote; + output + } + + // LOC 49 in the paper. + fn upon_decision(&mut self, round: u32) -> VecDeque { + let Some((block_hash, count)) = leading_vote(&self.precommits, round) else { + return VecDeque::new(); + }; + if *count < self.quorum { + return VecDeque::new(); + } + let Some(block_hash) = block_hash else { + return VecDeque::new(); + }; + let Some((proposed_value, _)) = self.proposals.get(&round) else { + return VecDeque::new(); + }; + if *proposed_value != Some(*block_hash) { + // If the proposal is None this could be due to an honest error (crash or network). + // If the proposal is valid, this can be caused by a malicious leader double proposing. + // We will rely on the sync protocol to catch us up if such a decision is reached. + error!("Proposal does not match quorum."); + return VecDeque::new(); + } + VecDeque::from([StateMachineEvent::Decision(*block_hash, round)]) + } } fn leading_vote( From da4c42e4bf5d331537b60d02aebb70f50180af84 Mon Sep 17 00:00:00 2001 From: Asmaa Magdoub Date: Sun, 6 Oct 2024 15:02:28 +0300 Subject: [PATCH 28/57] refactor(consensus): add future_round_upons as in the paper --- .../papyrus_consensus/src/state_machine.rs | 64 ++++++++++++++----- 1 file changed, 49 insertions(+), 15 deletions(-) diff --git a/crates/sequencing/papyrus_consensus/src/state_machine.rs b/crates/sequencing/papyrus_consensus/src/state_machine.rs index 67a6ba8141d..03f65a598d1 100644 --- a/crates/sequencing/papyrus_consensus/src/state_machine.rs +++ b/crates/sequencing/papyrus_consensus/src/state_machine.rs @@ -56,6 +56,7 @@ pub struct StateMachine { round: Round, step: Step, quorum: u32, + round_skip_threshold: u32, // {round: (block_hash, valid_round)} proposals: HashMap, Option)>, // {round: {block_hash: vote_count} @@ -76,6 +77,7 @@ impl StateMachine { round: 0, step: Step::Propose, quorum: (2 * total_weight / 3) + 1, + round_skip_threshold: total_weight / 3 + 1, proposals: HashMap::new(), prevotes: HashMap::new(), precommits: HashMap::new(), @@ -237,13 +239,11 @@ impl StateMachine { { let old = self.proposals.insert(round, (block_hash, valid_round)); assert!(old.is_none(), "SHC should handle conflicts & replays"); - if round < self.round { - return self.past_round_upons(round); + match round.cmp(&self.round) { + std::cmp::Ordering::Less => self.past_round_upons(round), + std::cmp::Ordering::Greater => self.future_round_upons(round, leader_fn), + std::cmp::Ordering::Equal => self.process_proposal(block_hash, round, leader_fn), } - if round != self.round { - return VecDeque::new(); - } - self.process_proposal(block_hash, round, leader_fn) } fn process_proposal( @@ -285,13 +285,16 @@ impl StateMachine { let prevote_count = self.prevotes.entry(round).or_default().entry(block_hash).or_insert(0); // TODO(matan): Use variable weight. *prevote_count += 1; - if round < self.round { - return self.past_round_upons(round); - } - if self.step != Step::Prevote || round != self.round { - return VecDeque::new(); + match round.cmp(&self.round) { + std::cmp::Ordering::Less => self.past_round_upons(round), + std::cmp::Ordering::Greater => self.future_round_upons(round, leader_fn), + std::cmp::Ordering::Equal => { + if self.step != Step::Prevote { + return VecDeque::new(); + } + self.check_prevote_quorum(round, leader_fn) + } } - self.check_prevote_quorum(round, leader_fn) } fn handle_timeout_prevote(&mut self, round: u32) -> VecDeque { @@ -316,10 +319,11 @@ impl StateMachine { self.precommits.entry(round).or_default().entry(block_hash).or_insert(0); // TODO(matan): Use variable weight. *precommit_count += 1; - if round < self.round { - return self.past_round_upons(round); + match round.cmp(&self.round) { + std::cmp::Ordering::Less => self.past_round_upons(round), + std::cmp::Ordering::Greater => self.future_round_upons(round, leader_fn), + std::cmp::Ordering::Equal => self.check_precommit_quorum(round, leader_fn), } - self.check_precommit_quorum(round, leader_fn) } fn handle_timeout_precommit( @@ -490,6 +494,36 @@ impl StateMachine { output } + fn future_round_upons( + &mut self, + round: u32, + leader_fn: &LeaderFn, + ) -> VecDeque + where + LeaderFn: Fn(Round) -> ValidatorId, + { + let num_prevotes = self.prevotes.get(&round).map_or(0, |v| v.values().sum()); + let num_precommits = self.precommits.get(&round).map_or(0, |v| v.values().sum()); + if num_prevotes >= self.round_skip_threshold || num_precommits >= self.round_skip_threshold + { + self.future_round_vote(round, leader_fn) + } else { + VecDeque::new() + } + } + + // LOC 55 in the paper. + fn future_round_vote( + &mut self, + round: u32, + leader_fn: &LeaderFn, + ) -> VecDeque + where + LeaderFn: Fn(Round) -> ValidatorId, + { + self.advance_to_round(round, leader_fn) + } + // LOC 28 in the paper. fn upon_reproposal(&mut self) -> VecDeque { if self.step != Step::Propose { From 2e2bd871c99cb6747ba947366018316c4400ba05 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 14:31:04 +0300 Subject: [PATCH 29/57] refactor(blockifier): refactor to_discounted_l1_gas (#1178) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1178) --- crates/blockifier/src/context.rs | 8 +++++++- crates/blockifier/src/fee/fee_checks.rs | 3 ++- crates/blockifier/src/fee/gas_usage_test.rs | 2 +- crates/blockifier/src/fee/resources.rs | 18 ++++++------------ .../src/transaction/account_transaction.rs | 2 +- .../transaction/account_transactions_test.rs | 6 +++--- 6 files changed, 20 insertions(+), 19 deletions(-) diff --git a/crates/blockifier/src/context.rs b/crates/blockifier/src/context.rs index 753309645a0..0cdf78a023b 100644 --- a/crates/blockifier/src/context.rs +++ b/crates/blockifier/src/context.rs @@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize}; use starknet_api::core::{ChainId, ContractAddress}; use starknet_api::transaction::GasVectorComputationMode; -use crate::blockifier::block::BlockInfo; +use crate::blockifier::block::{BlockInfo, GasPricesForFeeType}; use crate::bouncer::BouncerConfig; use crate::transaction::objects::{ FeeType, @@ -37,6 +37,12 @@ impl TransactionContext { TransactionInfo::Deprecated(_) => GasVectorComputationMode::NoL2Gas, } } + pub fn get_gas_prices(&self) -> &GasPricesForFeeType { + self.block_context + .block_info + .gas_prices + .get_gas_prices_by_fee_type(&self.tx_info.fee_type()) + } } #[derive(Clone, Debug)] diff --git a/crates/blockifier/src/fee/fee_checks.rs b/crates/blockifier/src/fee/fee_checks.rs index a47d4e8d1b6..921778e2dcf 100644 --- a/crates/blockifier/src/fee/fee_checks.rs +++ b/crates/blockifier/src/fee/fee_checks.rs @@ -174,7 +174,8 @@ impl FeeCheckReport { gas_vector: &GasVector, tx_context: &TransactionContext, ) -> FeeCheckResult<()> { - let total_discounted_gas_used = gas_vector.to_discounted_l1_gas(tx_context); + let total_discounted_gas_used = + gas_vector.to_discounted_l1_gas(tx_context.get_gas_prices()); if total_discounted_gas_used > l1_bounds.max_amount.into() { return Err(FeeCheckError::MaxGasAmountExceeded { resource: L1Gas, diff --git a/crates/blockifier/src/fee/gas_usage_test.rs b/crates/blockifier/src/fee/gas_usage_test.rs index ca148f9a6fa..fd20e1437d1 100644 --- a/crates/blockifier/src/fee/gas_usage_test.rs +++ b/crates/blockifier/src/fee/gas_usage_test.rs @@ -287,7 +287,7 @@ fn test_discounted_gas_from_gas_vector_computation() { BlockContext::create_for_testing().to_tx_context(&account_invoke_tx(invoke_tx_args! {})); let gas_usage = GasVector { l1_gas: 100_u8.into(), l1_data_gas: 2_u8.into(), ..Default::default() }; - let actual_result = gas_usage.to_discounted_l1_gas(&tx_context); + let actual_result = gas_usage.to_discounted_l1_gas(tx_context.get_gas_prices()); let result_div_ceil = gas_usage.l1_gas + (gas_usage.l1_data_gas.nonzero_checked_mul(DEFAULT_ETH_L1_DATA_GAS_PRICE).unwrap()) diff --git a/crates/blockifier/src/fee/resources.rs b/crates/blockifier/src/fee/resources.rs index dc6b894274b..e3312ef668c 100644 --- a/crates/blockifier/src/fee/resources.rs +++ b/crates/blockifier/src/fee/resources.rs @@ -5,7 +5,6 @@ use starknet_api::execution_resources::GasAmount; use starknet_api::transaction::{Fee, GasVectorComputationMode, Resource}; use crate::blockifier::block::GasPricesForFeeType; -use crate::context::TransactionContext; use crate::execution::call_info::{EventSummary, ExecutionSummary}; use crate::fee::eth_gas_constants; use crate::fee::fee_utils::get_vm_resources_cost; @@ -18,7 +17,6 @@ use crate::fee::gas_usage::{ }; use crate::state::cached_state::{StateChanges, StateChangesCount}; use crate::transaction::errors::TransactionFeeError; -use crate::transaction::objects::HasRelatedFeeType; use crate::utils::u64_from_usize; use crate::versioned_constants::{ resource_cost_to_u128_ratio, @@ -369,19 +367,15 @@ impl GasVector { /// summand, we get total_gas = (X + Y * DGP / GP). /// If this function is called with kzg_flag==false, then l1_data_gas==0, and this dicount /// function does nothing. - pub fn to_discounted_l1_gas(&self, tx_context: &TransactionContext) -> GasAmount { - let gas_prices = &tx_context.block_context.block_info.gas_prices; - let fee_type = tx_context.tx_info.fee_type(); - let l1_gas_price = gas_prices.get_l1_gas_price_by_fee_type(&fee_type); - let l1_data_gas_price = gas_prices.get_l1_data_gas_price_by_fee_type(&fee_type); - let l1_data_gas_fee = self.l1_data_gas.nonzero_saturating_mul(l1_data_gas_price); + pub fn to_discounted_l1_gas(&self, gas_prices: &GasPricesForFeeType) -> GasAmount { + let l1_data_gas_fee = self.l1_data_gas.nonzero_saturating_mul(gas_prices.l1_data_gas_price); let l1_data_gas_in_l1_gas_units = - l1_data_gas_fee.checked_div_ceil(l1_gas_price).unwrap_or_else(|| { + l1_data_gas_fee.checked_div_ceil(gas_prices.l1_gas_price).unwrap_or_else(|| { log::warn!( - "Discounted L1 gas cost overflowed: division of L1 data fee {:?} by regular \ - L1 gas price ({:?}) resulted in overflow.", + "Discounted L1 gas cost overflowed: division of L1 data fee ({}) by regular \ + L1 gas price ({}) resulted in overflow.", l1_data_gas_fee, - l1_gas_price + gas_prices.l1_gas_price ); GasAmount::MAX }); diff --git a/crates/blockifier/src/transaction/account_transaction.rs b/crates/blockifier/src/transaction/account_transaction.rs index a0c8ea6e36b..3208558502d 100644 --- a/crates/blockifier/src/transaction/account_transaction.rs +++ b/crates/blockifier/src/transaction/account_transaction.rs @@ -320,7 +320,7 @@ impl AccountTransaction { ValidResourceBounds::L1Gas(l1_gas_resource_bounds) => vec![( L1Gas, l1_gas_resource_bounds, - minimal_gas_amount_vector.to_discounted_l1_gas(tx_context), + minimal_gas_amount_vector.to_discounted_l1_gas(tx_context.get_gas_prices()), block_info.gas_prices.get_l1_gas_price_by_fee_type(fee_type), )], ValidResourceBounds::AllResources(AllResourceBounds { diff --git a/crates/blockifier/src/transaction/account_transactions_test.rs b/crates/blockifier/src/transaction/account_transactions_test.rs index fe554f81897..a7f19ff2bb4 100644 --- a/crates/blockifier/src/transaction/account_transactions_test.rs +++ b/crates/blockifier/src/transaction/account_transactions_test.rs @@ -501,10 +501,10 @@ fn test_max_fee_limit_validate( block_context: block_context.clone(), tx_info: account_tx.create_tx_info(), }; + let gas_prices = tx_context.get_gas_prices(); l1_resource_bounds( - estimated_min_gas_usage_vector.to_discounted_l1_gas(&tx_context), - block_info.gas_prices - .get_l1_gas_price_by_fee_type(&account_tx.fee_type()).into() + estimated_min_gas_usage_vector.to_discounted_l1_gas(gas_prices), + gas_prices.l1_gas_price.into(), ) } GasVectorComputationMode::All => create_all_resource_bounds( From 4e91f83ff9186546391c4280f90d032120add5f9 Mon Sep 17 00:00:00 2001 From: Ayelet Zilber <138376632+ayeletstarkware@users.noreply.github.com> Date: Wed, 9 Oct 2024 14:34:50 +0300 Subject: [PATCH 30/57] refactor(mempool): delete test support for account_nonces (#1267) --- crates/mempool/src/mempool_test.rs | 37 ++++-------------------------- 1 file changed, 5 insertions(+), 32 deletions(-) diff --git a/crates/mempool/src/mempool_test.rs b/crates/mempool/src/mempool_test.rs index 9eb0556735e..48d7c21acd5 100644 --- a/crates/mempool/src/mempool_test.rs +++ b/crates/mempool/src/mempool_test.rs @@ -12,7 +12,7 @@ use starknet_api::{contract_address, felt, invoke_tx_args, nonce, patricia_key}; use starknet_mempool_types::errors::MempoolError; use starknet_mempool_types::mempool_types::AccountState; -use crate::mempool::{AccountToNonce, AddTransactionArgs, Mempool, TransactionReference}; +use crate::mempool::{AddTransactionArgs, Mempool, TransactionReference}; use crate::test_utils::{add_tx, add_tx_expect_error, commit_block, get_txs_and_assert_expected}; use crate::transaction_pool::TransactionPool; use crate::transaction_queue::transaction_queue_test_utils::{ @@ -30,7 +30,6 @@ use crate::{add_tx_input, tx}; struct MempoolContent { tx_pool: Option, tx_queue_content: Option, - account_nonces: Option, } impl MempoolContent { @@ -42,16 +41,12 @@ impl MempoolContent { if let Some(tx_queue_content) = &self.tx_queue_content { tx_queue_content.assert_eq(&mempool.tx_queue); } - - if let Some(account_nonces) = &self.account_nonces { - assert_eq!(&mempool.account_nonces, account_nonces); - } } } impl From for Mempool { fn from(mempool_content: MempoolContent) -> Mempool { - let MempoolContent { tx_pool, tx_queue_content, account_nonces } = mempool_content; + let MempoolContent { tx_pool, tx_queue_content } = mempool_content; Mempool { tx_pool: tx_pool.unwrap_or_default(), tx_queue: tx_queue_content @@ -59,7 +54,7 @@ impl From for Mempool { .unwrap_or_default(), // TODO: Add implementation when needed. mempool_state: Default::default(), - account_nonces: account_nonces.unwrap_or_default(), + account_nonces: Default::default(), } } } @@ -68,7 +63,6 @@ impl From for Mempool { struct MempoolContentBuilder { tx_pool: Option, tx_queue_content_builder: TransactionQueueContentBuilder, - account_nonces: Option, } impl MempoolContentBuilder { @@ -100,24 +94,10 @@ impl MempoolContentBuilder { self } - fn with_account_nonces(mut self, account_nonce_pairs: A) -> Self - where - A: IntoIterator, - { - self.account_nonces = Some( - account_nonce_pairs - .into_iter() - .map(|(address, nonce)| (contract_address!(address), nonce!(nonce))) - .collect(), - ); - self - } - fn build(self) -> MempoolContent { MempoolContent { tx_pool: self.tx_pool, tx_queue_content: self.tx_queue_content_builder.build(), - account_nonces: self.account_nonces, } } @@ -351,12 +331,10 @@ fn test_add_tx(mut mempool: Mempool) { add_tx_inputs.sort_by_key(|input| std::cmp::Reverse(input.tx.tip().unwrap())); // Assert: transactions are ordered by priority. - let expected_account_nonces = [("0x0", 0), ("0x1", 1), ("0x2", 2)]; let expected_queue_txs: Vec = add_tx_inputs.iter().map(|input| TransactionReference::new(&input.tx)).collect(); let expected_pool_txs = add_tx_inputs.into_iter().map(|input| input.tx); let expected_mempool_content = MempoolContentBuilder::new() - .with_account_nonces(expected_account_nonces) .with_pool(expected_pool_txs) .with_priority_queue(expected_queue_txs) .build(); @@ -415,11 +393,9 @@ fn test_add_tx_lower_than_queued_nonce() { let tx = tx!(tx_hash: 1, sender_address: "0x0", tx_nonce: 1); let queue_txs = [TransactionReference::new(&tx)]; let pool_txs = [tx]; - let account_nonces = [("0x0", 1)]; let mut mempool = MempoolContentBuilder::new() .with_pool(pool_txs.clone()) .with_priority_queue(queue_txs) - .with_account_nonces(account_nonces) .build_into_mempool(); // Test and assert: original transaction remains. @@ -436,11 +412,8 @@ fn test_add_tx_lower_than_queued_nonce() { ); } - let expected_mempool_content = MempoolContentBuilder::new() - .with_pool(pool_txs) - .with_priority_queue(queue_txs) - .with_account_nonces(account_nonces) - .build(); + let expected_mempool_content = + MempoolContentBuilder::new().with_pool(pool_txs).with_priority_queue(queue_txs).build(); expected_mempool_content.assert_eq(&mempool); } From e4afb8928dc5f6ee98ba0dc42363817cf808ead4 Mon Sep 17 00:00:00 2001 From: Asmaa Magdoub Date: Sun, 6 Oct 2024 15:45:10 +0300 Subject: [PATCH 31/57] refactor(consensus): add current_round_upons as in the paper --- .../src/single_height_consensus_test.rs | 1 + .../papyrus_consensus/src/state_machine.rs | 420 ++++++++---------- .../src/state_machine_test.rs | 10 +- 3 files changed, 197 insertions(+), 234 deletions(-) diff --git a/crates/sequencing/papyrus_consensus/src/single_height_consensus_test.rs b/crates/sequencing/papyrus_consensus/src/single_height_consensus_test.rs index 83df42f727c..07669527ca8 100644 --- a/crates/sequencing/papyrus_consensus/src/single_height_consensus_test.rs +++ b/crates/sequencing/papyrus_consensus/src/single_height_consensus_test.rs @@ -450,6 +450,7 @@ async fn repropose() { .withf(move |msg: &ConsensusMessage| msg == &prevote(Some(BLOCK.id.0), 0, 1, *PROPOSER_ID)) .returning(move |_| Ok(())); shc.handle_message(&mut context, precommits[2].clone()).await.unwrap(); + shc.handle_event(&mut context, StateMachineEvent::TimeoutPrecommit(0)).await.unwrap(); let precommits = vec![ precommit(Some(BLOCK.id.0), 0, 1, *VALIDATOR_ID_1), diff --git a/crates/sequencing/papyrus_consensus/src/state_machine.rs b/crates/sequencing/papyrus_consensus/src/state_machine.rs index 03f65a598d1..55e7e70f995 100644 --- a/crates/sequencing/papyrus_consensus/src/state_machine.rs +++ b/crates/sequencing/papyrus_consensus/src/state_machine.rs @@ -7,10 +7,10 @@ #[path = "state_machine_test.rs"] mod state_machine_test; -use std::collections::{HashMap, VecDeque}; +use std::collections::{HashMap, HashSet, VecDeque}; use starknet_api::block::BlockHash; -use tracing::{error, trace}; +use tracing::trace; use crate::types::{ProposalContentId, Round, ValidatorId}; @@ -66,7 +66,11 @@ pub struct StateMachine { // events in `events_queue`. awaiting_get_proposal: bool, events_queue: VecDeque, - locked_value: Option<(ProposalContentId, Round)>, + locked_value_round: Option<(ProposalContentId, Round)>, + valid_value_round: Option<(ProposalContentId, Round)>, + prevote_quorum: HashSet, + mixed_prevote_quorum: HashSet, + mixed_precommit_quorum: HashSet, } impl StateMachine { @@ -83,7 +87,11 @@ impl StateMachine { precommits: HashMap::new(), awaiting_get_proposal: false, events_queue: VecDeque::new(), - locked_value: None, + locked_value_round: None, + valid_value_round: None, + prevote_quorum: HashSet::new(), + mixed_prevote_quorum: HashSet::new(), + mixed_precommit_quorum: HashSet::new(), } } @@ -205,7 +213,7 @@ impl StateMachine { "If the caller knows of a decision, it can just drop the state machine." ) } - StateMachineEvent::TimeoutPropose(round) => self.handle_timeout_proposal(round), + StateMachineEvent::TimeoutPropose(round) => self.handle_timeout_propose(round), StateMachineEvent::TimeoutPrevote(round) => self.handle_timeout_prevote(round), StateMachineEvent::TimeoutPrecommit(round) => { self.handle_timeout_precommit(round, leader_fn) @@ -239,37 +247,16 @@ impl StateMachine { { let old = self.proposals.insert(round, (block_hash, valid_round)); assert!(old.is_none(), "SHC should handle conflicts & replays"); - match round.cmp(&self.round) { - std::cmp::Ordering::Less => self.past_round_upons(round), - std::cmp::Ordering::Greater => self.future_round_upons(round, leader_fn), - std::cmp::Ordering::Equal => self.process_proposal(block_hash, round, leader_fn), - } - } - - fn process_proposal( - &mut self, - block_hash: Option, - round: u32, - leader_fn: &LeaderFn, - ) -> VecDeque - where - LeaderFn: Fn(Round) -> ValidatorId, - { - if self.step != Step::Propose { - return VecDeque::new(); - } - - let mut output = VecDeque::from([StateMachineEvent::Prevote(block_hash, round)]); - output.append(&mut self.advance_to_step(Step::Prevote, leader_fn)); - output + self.map_round_to_upons(round, leader_fn) } - fn handle_timeout_proposal(&mut self, round: u32) -> VecDeque { + fn handle_timeout_propose(&mut self, round: u32) -> VecDeque { if self.step != Step::Propose || round != self.round { return VecDeque::new(); }; - self.step = Step::Prevote; - VecDeque::from([StateMachineEvent::Prevote(None, round)]) + let mut output = VecDeque::from([StateMachineEvent::Prevote(None, round)]); + output.append(&mut self.advance_to_step(Step::Prevote)); + output } // A prevote from a peer (or self) node. @@ -285,24 +272,16 @@ impl StateMachine { let prevote_count = self.prevotes.entry(round).or_default().entry(block_hash).or_insert(0); // TODO(matan): Use variable weight. *prevote_count += 1; - match round.cmp(&self.round) { - std::cmp::Ordering::Less => self.past_round_upons(round), - std::cmp::Ordering::Greater => self.future_round_upons(round, leader_fn), - std::cmp::Ordering::Equal => { - if self.step != Step::Prevote { - return VecDeque::new(); - } - self.check_prevote_quorum(round, leader_fn) - } - } + self.map_round_to_upons(round, leader_fn) } fn handle_timeout_prevote(&mut self, round: u32) -> VecDeque { if self.step != Step::Prevote || round != self.round { return VecDeque::new(); }; - self.step = Step::Precommit; - VecDeque::from([StateMachineEvent::Precommit(None, round)]) + let mut output = VecDeque::from([StateMachineEvent::Precommit(None, round)]); + output.append(&mut self.advance_to_step(Step::Precommit)); + output } // A precommit from a peer (or self) node. @@ -319,11 +298,7 @@ impl StateMachine { self.precommits.entry(round).or_default().entry(block_hash).or_insert(0); // TODO(matan): Use variable weight. *precommit_count += 1; - match round.cmp(&self.round) { - std::cmp::Ordering::Less => self.past_round_upons(round), - std::cmp::Ordering::Greater => self.future_round_upons(round, leader_fn), - std::cmp::Ordering::Equal => self.check_precommit_quorum(round, leader_fn), - } + self.map_round_to_upons(round, leader_fn) } fn handle_timeout_precommit( @@ -340,24 +315,8 @@ impl StateMachine { self.advance_to_round(round + 1, leader_fn) } - fn advance_to_step( - &mut self, - step: Step, - leader_fn: &LeaderFn, - ) -> VecDeque - where - LeaderFn: Fn(Round) -> ValidatorId, - { - self.step = step; - // Check for an existing quorum in case messages arrived out of order. - match self.step { - Step::Propose => unreachable!("Advancing to Propose is done by advancing rounds"), - Step::Prevote => self.check_prevote_quorum(self.round, leader_fn), - Step::Precommit => self.check_precommit_quorum(self.round, leader_fn), - } - } - - fn check_prevote_quorum( + // LOC 11 in the paper. + fn advance_to_round( &mut self, round: u32, leader_fn: &LeaderFn, @@ -365,126 +324,60 @@ impl StateMachine { where LeaderFn: Fn(Round) -> ValidatorId, { - assert_eq!(round, self.round, "check_prevote_quorum is only called for the current round"); - let num_votes = self.prevotes.get(&round).map_or(0, |v| v.values().sum()); - if num_votes < self.quorum { - return VecDeque::new(); - } - let mut output = VecDeque::from([StateMachineEvent::TimeoutPrevote(round)]); - let Some((block_hash, count)) = leading_vote(&self.prevotes, round) else { - return output; - }; - if *count < self.quorum { - return output; - } - if block_hash.is_none() { - output.append(&mut self.send_precommit(*block_hash, round, leader_fn)); - return output; - } - let Some((proposed_value, _)) = self.proposals.get(&round) else { - return output; - }; - if proposed_value != block_hash { - // TODO(matan): This can be caused by a malicious leader double proposing. - panic!("Proposal does not match quorum."); - } - - self.locked_value = match self.locked_value { - Some((_, locked_round)) if locked_round >= round => self.locked_value, - _ => block_hash.map(|hash| (hash, round)), + self.round = round; + self.step = Step::Propose; + let mut output = if self.id == leader_fn(self.round) { + // Leader. + match self.valid_value_round { + Some((proposal_id, valid_round)) => VecDeque::from([StateMachineEvent::Proposal( + Some(proposal_id), + self.round, + Some(valid_round), + )]), + None => { + self.awaiting_get_proposal = true; + // Upon conditions are not checked while awaiting a new proposal. + return VecDeque::from([StateMachineEvent::GetProposal(None, self.round)]); + } + } + } else { + VecDeque::from([StateMachineEvent::TimeoutPropose(self.round)]) }; - - output.append(&mut self.send_precommit(*block_hash, round, leader_fn)); + output.append(&mut self.current_round_upons()); output } - fn check_precommit_quorum( - &mut self, - round: u32, - leader_fn: &LeaderFn, - ) -> VecDeque - where - LeaderFn: Fn(Round) -> ValidatorId, - { - let num_votes = self.precommits.get(&round).map_or(0, |v| v.values().sum()); - if num_votes < self.quorum { - return VecDeque::new(); - } - let mut output = VecDeque::from([StateMachineEvent::TimeoutPrecommit(round)]); - let Some((block_hash, count)) = leading_vote(&self.precommits, round) else { - return output; - }; - if *count < self.quorum { - return output; - } - if block_hash.is_none() { - if round == self.round { - output.append(&mut self.advance_to_round(round + 1, leader_fn)); - return output; - } else { - // NIL quorum reached on a different round. - return output; - } - } - let Some((proposed_value, _)) = self.proposals.get(&round) else { - return output; - }; - if proposed_value != block_hash { - // TODO(matan): This can be caused by a malicious leader double proposing. - panic!("Proposal does not match quorum."); - } - if let Some(block_hash) = block_hash { - output.append(&mut VecDeque::from([StateMachineEvent::Decision(*block_hash, round)])); - output - } else { - // NIL quorum reached on a different round. - output - } + fn advance_to_step(&mut self, step: Step) -> VecDeque { + assert_ne!(step, Step::Propose, "Advancing to Propose is done by advancing rounds"); + self.step = step; + self.current_round_upons() } - fn send_precommit( + fn map_round_to_upons( &mut self, - block_hash: Option, round: u32, leader_fn: &LeaderFn, ) -> VecDeque where LeaderFn: Fn(Round) -> ValidatorId, { - let mut output = VecDeque::from([StateMachineEvent::Precommit(block_hash, round)]); - output.append(&mut self.advance_to_step(Step::Precommit, leader_fn)); - output + match round.cmp(&self.round) { + std::cmp::Ordering::Less => self.past_round_upons(round), + std::cmp::Ordering::Equal => self.current_round_upons(), + std::cmp::Ordering::Greater => self.maybe_advance_to_round(round, leader_fn), + } } - fn advance_to_round( - &mut self, - round: u32, - leader_fn: &LeaderFn, - ) -> VecDeque - where - LeaderFn: Fn(Round) -> ValidatorId, - { - self.round = round; - self.step = Step::Propose; - if self.id == leader_fn(self.round) { - match self.locked_value { - Some((proposal_content_id, valid_round)) => { - return VecDeque::from([StateMachineEvent::Proposal( - Some(proposal_content_id), - self.round, - Some(valid_round), - )]); - } - None => { - self.awaiting_get_proposal = true; - return VecDeque::from([StateMachineEvent::GetProposal(None, self.round)]); - } - } - } - let Some((proposal, _)) = self.proposals.get(&round) else { - return VecDeque::from([StateMachineEvent::TimeoutPropose(round)]); - }; - self.process_proposal(*proposal, round, leader_fn) + fn current_round_upons(&mut self) -> VecDeque { + let mut output = VecDeque::new(); + output.append(&mut self.upon_new_proposal()); + output.append(&mut self.upon_reproposal()); + output.append(&mut self.maybe_initiate_timeout_prevote()); + output.append(&mut self.upon_prevote_quorum()); + output.append(&mut self.upon_nil_prevote_quorum()); + output.append(&mut self.maybe_initiate_timeout_precommit()); + output.append(&mut self.upon_decision(self.round)); + output } fn past_round_upons(&mut self, round: u32) -> VecDeque { @@ -494,34 +387,27 @@ impl StateMachine { output } - fn future_round_upons( - &mut self, - round: u32, - leader_fn: &LeaderFn, - ) -> VecDeque - where - LeaderFn: Fn(Round) -> ValidatorId, - { - let num_prevotes = self.prevotes.get(&round).map_or(0, |v| v.values().sum()); - let num_precommits = self.precommits.get(&round).map_or(0, |v| v.values().sum()); - if num_prevotes >= self.round_skip_threshold || num_precommits >= self.round_skip_threshold - { - self.future_round_vote(round, leader_fn) - } else { - VecDeque::new() + // LOC 22 in the paper. + fn upon_new_proposal(&mut self) -> VecDeque { + // StateMachine assumes that the proposer is valid. + if self.step != Step::Propose { + return VecDeque::new(); } - } - - // LOC 55 in the paper. - fn future_round_vote( - &mut self, - round: u32, - leader_fn: &LeaderFn, - ) -> VecDeque - where - LeaderFn: Fn(Round) -> ValidatorId, - { - self.advance_to_round(round, leader_fn) + let Some((proposal_id, valid_round)) = self.proposals.get(&self.round) else { + return VecDeque::new(); + }; + if valid_round.is_some() { + return VecDeque::new(); + } + let mut output = if proposal_id.is_some_and(|v| { + self.locked_value_round.map_or(true, |(locked_value, _)| v == locked_value) + }) { + VecDeque::from([StateMachineEvent::Prevote(*proposal_id, self.round)]) + } else { + VecDeque::from([StateMachineEvent::Prevote(None, self.round)]) + }; + output.append(&mut self.advance_to_step(Step::Prevote)); + output } // LOC 28 in the paper. @@ -529,7 +415,7 @@ impl StateMachine { if self.step != Step::Propose { return VecDeque::new(); } - let Some((block_hash, valid_round)) = self.proposals.get(&self.round) else { + let Some((proposal_id, valid_round)) = self.proposals.get(&self.round) else { return VecDeque::new(); }; let Some(valid_round) = valid_round else { @@ -538,58 +424,132 @@ impl StateMachine { if valid_round >= &self.round { return VecDeque::new(); } - let Some(round_prevotes) = self.prevotes.get(valid_round) else { - return VecDeque::new(); - }; - let Some(count) = round_prevotes.get(block_hash) else { return VecDeque::new() }; - - if count < &self.quorum { + if !value_has_enough_votes(&self.prevotes, *valid_round, proposal_id, self.quorum) { return VecDeque::new(); } - let output = if block_hash.is_some_and(|v| { - self.locked_value.is_none() - || self.locked_value.is_some_and(|(locked_value, locked_round)| { - locked_round <= *valid_round || locked_value == v - }) + let mut output = if proposal_id.is_some_and(|v| { + self.locked_value_round.map_or(true, |(locked_value, locked_round)| { + locked_round <= *valid_round || locked_value == v + }) }) { - VecDeque::from([StateMachineEvent::Prevote(*block_hash, self.round)]) + VecDeque::from([StateMachineEvent::Prevote(*proposal_id, self.round)]) } else { VecDeque::from([StateMachineEvent::Prevote(None, self.round)]) }; - - self.step = Step::Prevote; + output.append(&mut self.advance_to_step(Step::Prevote)); output } - // LOC 49 in the paper. - fn upon_decision(&mut self, round: u32) -> VecDeque { - let Some((block_hash, count)) = leading_vote(&self.precommits, round) else { + // LOC 34 in the paper. + fn maybe_initiate_timeout_prevote(&mut self) -> VecDeque { + if self.step != Step::Prevote { return VecDeque::new(); - }; - if *count < self.quorum { + } + if !round_has_enough_votes(&self.prevotes, self.round, self.quorum) { + return VecDeque::new(); + } + // Getting mixed prevote quorum for the first time. + if !self.mixed_prevote_quorum.insert(self.round) { return VecDeque::new(); } - let Some(block_hash) = block_hash else { + VecDeque::from([StateMachineEvent::TimeoutPrevote(self.round)]) + } + + // LOC 36 in the paper. + fn upon_prevote_quorum(&mut self) -> VecDeque { + if self.step == Step::Propose { + return VecDeque::new(); + } + let Some((Some(proposal_id), _)) = self.proposals.get(&self.round) else { return VecDeque::new(); }; - let Some((proposed_value, _)) = self.proposals.get(&round) else { + if !value_has_enough_votes(&self.prevotes, self.round, &Some(*proposal_id), self.quorum) { + return VecDeque::new(); + } + // Getting prevote quorum for the first time. + if !self.prevote_quorum.insert(self.round) { + return VecDeque::new(); + } + self.valid_value_round = Some((*proposal_id, self.round)); + if self.step != Step::Prevote { + return VecDeque::new(); + } + self.locked_value_round = Some((*proposal_id, self.round)); + let mut output = + VecDeque::from([StateMachineEvent::Precommit(Some(*proposal_id), self.round)]); + output.append(&mut self.advance_to_step(Step::Precommit)); + output + } + + // LOC 44 in the paper. + fn upon_nil_prevote_quorum(&mut self) -> VecDeque { + if self.step != Step::Prevote { + return VecDeque::new(); + } + if !value_has_enough_votes(&self.prevotes, self.round, &None, self.quorum) { + return VecDeque::new(); + } + let mut output = VecDeque::from([StateMachineEvent::Precommit(None, self.round)]); + output.append(&mut self.advance_to_step(Step::Precommit)); + output + } + + // LOC 47 in the paper. + fn maybe_initiate_timeout_precommit(&mut self) -> VecDeque { + if !round_has_enough_votes(&self.precommits, self.round, self.quorum) { + return VecDeque::new(); + } + // Getting mixed precommit quorum for the first time. + if !self.mixed_precommit_quorum.insert(self.round) { + return VecDeque::new(); + } + VecDeque::from([StateMachineEvent::TimeoutPrecommit(self.round)]) + } + + // LOC 49 in the paper. + fn upon_decision(&mut self, round: u32) -> VecDeque { + let Some((Some(proposal_id), _)) = self.proposals.get(&round) else { return VecDeque::new(); }; - if *proposed_value != Some(*block_hash) { - // If the proposal is None this could be due to an honest error (crash or network). - // If the proposal is valid, this can be caused by a malicious leader double proposing. - // We will rely on the sync protocol to catch us up if such a decision is reached. - error!("Proposal does not match quorum."); + if !value_has_enough_votes(&self.precommits, round, &Some(*proposal_id), self.quorum) { return VecDeque::new(); } - VecDeque::from([StateMachineEvent::Decision(*block_hash, round)]) + + VecDeque::from([StateMachineEvent::Decision(*proposal_id, round)]) } + + // LOC 55 in the paper. + fn maybe_advance_to_round( + &mut self, + round: u32, + leader_fn: &LeaderFn, + ) -> VecDeque + where + LeaderFn: Fn(Round) -> ValidatorId, + { + if round_has_enough_votes(&self.prevotes, round, self.round_skip_threshold) + || round_has_enough_votes(&self.precommits, round, self.round_skip_threshold) + { + self.advance_to_round(round, leader_fn) + } else { + VecDeque::new() + } + } +} + +fn round_has_enough_votes( + votes: &HashMap, u32>>, + round: u32, + threshold: u32, +) -> bool { + votes.get(&round).map_or(0, |v| v.values().sum()) >= threshold } -fn leading_vote( +fn value_has_enough_votes( votes: &HashMap, u32>>, round: u32, -) -> Option<(&Option, &u32)> { - // We don't care which value is chosen in the case of a tie, since consensus requires 2/3+1. - votes.get(&round)?.iter().max_by(|a, b| a.1.cmp(b.1)) + value: &Option, + threshold: u32, +) -> bool { + votes.get(&round).map_or(0, |v| *v.get(value).unwrap_or(&0)) >= threshold } diff --git a/crates/sequencing/papyrus_consensus/src/state_machine_test.rs b/crates/sequencing/papyrus_consensus/src/state_machine_test.rs index 58ce24c3a8f..9c605a37233 100644 --- a/crates/sequencing/papyrus_consensus/src/state_machine_test.rs +++ b/crates/sequencing/papyrus_consensus/src/state_machine_test.rs @@ -144,8 +144,6 @@ fn validator_receives_votes_first() { assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::Prevote(BLOCK_HASH, ROUND)); assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::TimeoutPrevote(ROUND)); assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::Precommit(BLOCK_HASH, ROUND)); - // Timeout events should be triggered only once, will be fixed. - assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::TimeoutPrecommit(ROUND)); assert_eq!( wrapper.next_event().unwrap(), StateMachineEvent::Decision(BLOCK_HASH.unwrap(), ROUND) @@ -249,7 +247,9 @@ fn advance_to_the_next_round() { wrapper.send_precommit(None, ROUND); assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::TimeoutPrecommit(ROUND)); + wrapper.send_timeout_precommit(ROUND); // The Node sends Prevote after advancing to the next round. + assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::TimeoutPropose(ROUND + 1)); assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::Prevote(BLOCK_HASH, ROUND + 1)); } @@ -265,6 +265,7 @@ fn prevote_when_receiving_proposal_in_current_round() { wrapper.send_precommit(None, ROUND); wrapper.send_precommit(None, ROUND); assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::TimeoutPrecommit(ROUND)); + wrapper.send_timeout_precommit(ROUND); // The node starts the next round, shouldn't prevote when receiving a proposal for the // previous round. @@ -334,6 +335,9 @@ fn dont_handle_enqueued_while_awaiting_get_proposal() { wrapper.send_get_proposal(BLOCK_HASH, ROUND); assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::Proposal(BLOCK_HASH, ROUND, None)); assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::TimeoutPrecommit(ROUND)); + + // Timeout and advance on to the next round. + wrapper.send_timeout_precommit(ROUND); assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::GetProposal(None, ROUND + 1)); assert!(wrapper.next_event().is_none()); @@ -344,8 +348,6 @@ fn dont_handle_enqueued_while_awaiting_get_proposal() { StateMachineEvent::Proposal(BLOCK_HASH, ROUND + 1, None) ); assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::TimeoutPrecommit(ROUND + 1)); - assert_eq!(wrapper.next_event().unwrap(), StateMachineEvent::GetProposal(None, ROUND + 2)); - assert!(wrapper.next_event().is_none()); } #[test] From 1d5cdc0496c06fc0f0cde6737495dcc237ebc90c Mon Sep 17 00:00:00 2001 From: guy-starkware Date: Wed, 9 Oct 2024 04:41:49 -0700 Subject: [PATCH 32/57] feat: add display impl for StreamMessage (#1071) --- crates/papyrus_protobuf/src/consensus.rs | 25 +++++++++++++++ .../src/converters/consensus_test.rs | 32 +++++++++++++++++++ 2 files changed, 57 insertions(+) diff --git a/crates/papyrus_protobuf/src/consensus.rs b/crates/papyrus_protobuf/src/consensus.rs index 50afaed1bd8..5cbef8d1ce0 100644 --- a/crates/papyrus_protobuf/src/consensus.rs +++ b/crates/papyrus_protobuf/src/consensus.rs @@ -59,6 +59,31 @@ pub struct StreamMessage> + TryFrom, Error = ProtobufCon pub message_id: u64, } +impl std::fmt::Display for StreamMessage +where + T: Clone + Into> + TryFrom, Error = ProtobufConversionError>, +{ + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + // TODO(guyn): add option to display when message is Fin and doesn't have content (PR #1048) + if let StreamMessageBody::Content(message) = &self.message { + let message: Vec = message.clone().into(); + write!( + f, + "StreamMessage {{ stream_id: {}, message_id: {}, message_length: {}}}", + self.stream_id, + self.message_id, + message.len(), + ) + } else { + write!( + f, + "StreamMessage {{ stream_id: {}, message_id: {}, message is fin }}", + self.stream_id, self.message_id, + ) + } + } +} + // TODO(Guy): Remove after implementing broadcast streams. #[allow(missing_docs)] pub struct ProposalWrapper(pub Proposal); diff --git a/crates/papyrus_protobuf/src/converters/consensus_test.rs b/crates/papyrus_protobuf/src/converters/consensus_test.rs index 5397d0ff53c..51810f9e612 100644 --- a/crates/papyrus_protobuf/src/converters/consensus_test.rs +++ b/crates/papyrus_protobuf/src/converters/consensus_test.rs @@ -146,3 +146,35 @@ fn convert_proposal_to_vec_u8_and_back() { let res_data = Proposal::try_from(bytes_data).unwrap(); assert_eq!(proposal, res_data); } + +#[test] +fn stream_message_display() { + let mut rng = get_rng(); + let stream_id = 42; + let message_id = 127; + let proposal = Proposal::get_test_instance(&mut rng); + let proposal_bytes: Vec = proposal.clone().into(); + let proposal_length = proposal_bytes.len(); + let content = StreamMessageBody::Content(proposal); + let message = StreamMessage { message: content, stream_id, message_id }; + + let txt = message.to_string(); + assert_eq!( + txt, + format!( + "StreamMessage {{ stream_id: {}, message_id: {}, message_length: {}}}", + stream_id, message_id, proposal_length + ) + ); + + let content: StreamMessageBody = StreamMessageBody::Fin; + let message = StreamMessage { message: content, stream_id, message_id }; + let txt = message.to_string(); + assert_eq!( + txt, + format!( + "StreamMessage {{ stream_id: {}, message_id: {}, message is fin }}", + stream_id, message_id + ) + ); +} From 53624e6d721433c2af2c424af3ce7fb99e16532b Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 14:55:32 +0300 Subject: [PATCH 33/57] refactor(blockifier,starknet_api): migrate GasVector from blockifier to starknet_api (#1179) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1179) --- Cargo.lock | 1 + crates/blockifier/src/blockifier/block.rs | 26 ++--- crates/blockifier/src/context.rs | 5 +- crates/blockifier/src/fee/fee_checks.rs | 3 +- crates/blockifier/src/fee/fee_test.rs | 3 +- crates/blockifier/src/fee/fee_utils.rs | 3 +- crates/blockifier/src/fee/gas_usage.rs | 2 +- crates/blockifier/src/fee/gas_usage_test.rs | 3 +- crates/blockifier/src/fee/receipt.rs | 2 +- crates/blockifier/src/fee/receipt_test.rs | 3 +- crates/blockifier/src/fee/resources.rs | 95 +------------------ crates/blockifier/src/test_utils.rs | 4 +- .../src/transaction/account_transaction.rs | 4 +- .../src/transaction/execution_flavors_test.rs | 3 +- crates/blockifier/src/transaction/objects.rs | 2 +- .../src/transaction/transactions_test.rs | 6 +- .../src/py_block_executor.rs | 2 +- crates/papyrus_execution/src/objects.rs | 2 +- crates/starknet_api/Cargo.toml | 1 + crates/starknet_api/src/block.rs | 7 ++ .../starknet_api/src/execution_resources.rs | 88 ++++++++++++++++- 21 files changed, 132 insertions(+), 133 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 4e30e3092e1..8e598929505 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -10113,6 +10113,7 @@ dependencies = [ "hex", "indexmap 2.6.0", "itertools 0.12.1", + "log", "num-bigint 0.4.6", "pretty_assertions", "primitive-types", diff --git a/crates/blockifier/src/blockifier/block.rs b/crates/blockifier/src/blockifier/block.rs index 385557807ac..ead1856f362 100644 --- a/crates/blockifier/src/blockifier/block.rs +++ b/crates/blockifier/src/blockifier/block.rs @@ -1,6 +1,13 @@ use log::warn; use serde::{Deserialize, Serialize}; -use starknet_api::block::{BlockHash, BlockNumber, BlockTimestamp, GasPrice, NonzeroGasPrice}; +use starknet_api::block::{ + BlockHash, + BlockNumber, + BlockTimestamp, + GasPrice, + GasPriceVector, + NonzeroGasPrice, +}; use starknet_api::core::ContractAddress; use starknet_api::state::StorageKey; use starknet_types_core::felt::Felt; @@ -28,15 +35,8 @@ pub struct BlockInfo { #[derive(Clone, Debug)] pub struct GasPrices { - eth_gas_prices: GasPricesForFeeType, // In wei. - strk_gas_prices: GasPricesForFeeType, // In fri. -} - -#[derive(Clone, Debug)] -pub struct GasPricesForFeeType { - pub l1_gas_price: NonzeroGasPrice, - pub l1_data_gas_price: NonzeroGasPrice, - pub l2_gas_price: NonzeroGasPrice, + eth_gas_prices: GasPriceVector, // In wei. + strk_gas_prices: GasPriceVector, // In fri. } impl GasPrices { @@ -69,12 +69,12 @@ impl GasPrices { } Self { - eth_gas_prices: GasPricesForFeeType { + eth_gas_prices: GasPriceVector { l1_gas_price: eth_l1_gas_price, l1_data_gas_price: eth_l1_data_gas_price, l2_gas_price: eth_l2_gas_price, }, - strk_gas_prices: GasPricesForFeeType { + strk_gas_prices: GasPriceVector { l1_gas_price: strk_l1_gas_price, l1_data_gas_price: strk_l1_data_gas_price, l2_gas_price: strk_l2_gas_price, @@ -94,7 +94,7 @@ impl GasPrices { self.get_gas_prices_by_fee_type(fee_type).l2_gas_price } - pub fn get_gas_prices_by_fee_type(&self, fee_type: &FeeType) -> &GasPricesForFeeType { + pub fn get_gas_prices_by_fee_type(&self, fee_type: &FeeType) -> &GasPriceVector { match fee_type { FeeType::Strk => &self.strk_gas_prices, FeeType::Eth => &self.eth_gas_prices, diff --git a/crates/blockifier/src/context.rs b/crates/blockifier/src/context.rs index 0cdf78a023b..10603a72cf4 100644 --- a/crates/blockifier/src/context.rs +++ b/crates/blockifier/src/context.rs @@ -3,10 +3,11 @@ use std::collections::BTreeMap; use papyrus_config::dumping::{append_sub_config_name, ser_param, SerializeConfig}; use papyrus_config::{ParamPath, ParamPrivacyInput, SerializedParam}; use serde::{Deserialize, Serialize}; +use starknet_api::block::GasPriceVector; use starknet_api::core::{ChainId, ContractAddress}; use starknet_api::transaction::GasVectorComputationMode; -use crate::blockifier::block::{BlockInfo, GasPricesForFeeType}; +use crate::blockifier::block::BlockInfo; use crate::bouncer::BouncerConfig; use crate::transaction::objects::{ FeeType, @@ -37,7 +38,7 @@ impl TransactionContext { TransactionInfo::Deprecated(_) => GasVectorComputationMode::NoL2Gas, } } - pub fn get_gas_prices(&self) -> &GasPricesForFeeType { + pub fn get_gas_prices(&self) -> &GasPriceVector { self.block_context .block_info .gas_prices diff --git a/crates/blockifier/src/fee/fee_checks.rs b/crates/blockifier/src/fee/fee_checks.rs index 921778e2dcf..383f7584338 100644 --- a/crates/blockifier/src/fee/fee_checks.rs +++ b/crates/blockifier/src/fee/fee_checks.rs @@ -1,4 +1,4 @@ -use starknet_api::execution_resources::GasAmount; +use starknet_api::execution_resources::{GasAmount, GasVector}; use starknet_api::transaction::Resource::{self, L1DataGas, L1Gas, L2Gas}; use starknet_api::transaction::{AllResourceBounds, Fee, ResourceBounds, ValidResourceBounds}; use starknet_types_core::felt::Felt; @@ -7,7 +7,6 @@ use thiserror::Error; use crate::context::TransactionContext; use crate::fee::fee_utils::{get_balance_and_if_covers_fee, get_fee_by_gas_vector}; use crate::fee::receipt::TransactionReceipt; -use crate::fee::resources::GasVector; use crate::state::state_api::StateReader; use crate::transaction::errors::TransactionExecutionError; use crate::transaction::objects::{FeeType, TransactionExecutionResult, TransactionInfo}; diff --git a/crates/blockifier/src/fee/fee_test.rs b/crates/blockifier/src/fee/fee_test.rs index dfe067a8b9a..6d0ac555666 100644 --- a/crates/blockifier/src/fee/fee_test.rs +++ b/crates/blockifier/src/fee/fee_test.rs @@ -2,7 +2,7 @@ use assert_matches::assert_matches; use cairo_vm::types::builtin_name::BuiltinName; use rstest::rstest; use starknet_api::block::NonzeroGasPrice; -use starknet_api::execution_resources::GasAmount; +use starknet_api::execution_resources::{GasAmount, GasVector}; use starknet_api::invoke_tx_args; use starknet_api::transaction::{Fee, GasVectorComputationMode, Resource, ValidResourceBounds}; @@ -11,7 +11,6 @@ use crate::context::BlockContext; use crate::fee::fee_checks::{FeeCheckError, FeeCheckReportFields, PostExecutionReport}; use crate::fee::fee_utils::{get_fee_by_gas_vector, get_vm_resources_cost}; use crate::fee::receipt::TransactionReceipt; -use crate::fee::resources::GasVector; use crate::test_utils::contracts::FeatureContract; use crate::test_utils::initial_test_state::test_state; use crate::test_utils::{ diff --git a/crates/blockifier/src/fee/fee_utils.rs b/crates/blockifier/src/fee/fee_utils.rs index 04ed53f58e7..4646b50d5d0 100644 --- a/crates/blockifier/src/fee/fee_utils.rs +++ b/crates/blockifier/src/fee/fee_utils.rs @@ -4,6 +4,7 @@ use cairo_vm::types::builtin_name::BuiltinName; use cairo_vm::vm::runners::cairo_runner::ExecutionResources; use num_bigint::BigUint; use starknet_api::core::ContractAddress; +use starknet_api::execution_resources::GasVector; use starknet_api::state::StorageKey; use starknet_api::transaction::ValidResourceBounds::{AllResources, L1Gas}; use starknet_api::transaction::{AllResourceBounds, Fee, GasVectorComputationMode, Resource}; @@ -13,7 +14,7 @@ use crate::abi::abi_utils::get_fee_token_var_address; use crate::abi::sierra_types::next_storage_key; use crate::blockifier::block::BlockInfo; use crate::context::{BlockContext, TransactionContext}; -use crate::fee::resources::{GasVector, TransactionFeeResult}; +use crate::fee::resources::TransactionFeeResult; use crate::state::state_api::StateReader; use crate::transaction::errors::TransactionFeeError; use crate::transaction::objects::{ExecutionResourcesTraits, FeeType, TransactionInfo}; diff --git a/crates/blockifier/src/fee/gas_usage.rs b/crates/blockifier/src/fee/gas_usage.rs index 36fbda8b599..1c3fb4de885 100644 --- a/crates/blockifier/src/fee/gas_usage.rs +++ b/crates/blockifier/src/fee/gas_usage.rs @@ -1,11 +1,11 @@ use cairo_vm::vm::runners::cairo_runner::ExecutionResources; +use starknet_api::execution_resources::GasVector; use starknet_api::transaction::GasVectorComputationMode; use super::fee_utils::get_vm_resources_cost; use crate::abi::constants; use crate::context::BlockContext; use crate::fee::eth_gas_constants; -use crate::fee::resources::GasVector; use crate::state::cached_state::StateChangesCount; use crate::transaction::account_transaction::AccountTransaction; use crate::utils::u64_from_usize; diff --git a/crates/blockifier/src/fee/gas_usage_test.rs b/crates/blockifier/src/fee/gas_usage_test.rs index fd20e1437d1..dea634aa451 100644 --- a/crates/blockifier/src/fee/gas_usage_test.rs +++ b/crates/blockifier/src/fee/gas_usage_test.rs @@ -3,7 +3,7 @@ use std::sync::Arc; use num_rational::Ratio; use pretty_assertions::assert_eq; use rstest::{fixture, rstest}; -use starknet_api::execution_resources::GasAmount; +use starknet_api::execution_resources::{GasAmount, GasVector}; use starknet_api::invoke_tx_args; use starknet_api::transaction::{EventContent, EventData, EventKey, GasVectorComputationMode}; use starknet_types_core::felt::Felt; @@ -16,7 +16,6 @@ use crate::fee::fee_utils::get_fee_by_gas_vector; use crate::fee::gas_usage::{get_da_gas_cost, get_message_segment_length}; use crate::fee::resources::{ ComputationResources, - GasVector, StarknetResources, StateResources, TransactionResources, diff --git a/crates/blockifier/src/fee/receipt.rs b/crates/blockifier/src/fee/receipt.rs index b0b4707c4e6..cb17af785cb 100644 --- a/crates/blockifier/src/fee/receipt.rs +++ b/crates/blockifier/src/fee/receipt.rs @@ -1,12 +1,12 @@ use cairo_vm::vm::runners::cairo_runner::ExecutionResources; use starknet_api::core::ContractAddress; +use starknet_api::execution_resources::GasVector; use starknet_api::transaction::Fee; use crate::context::TransactionContext; use crate::execution::call_info::ExecutionSummary; use crate::fee::resources::{ ComputationResources, - GasVector, StarknetResources, StateResources, TransactionResources, diff --git a/crates/blockifier/src/fee/receipt_test.rs b/crates/blockifier/src/fee/receipt_test.rs index 13654e6001d..671b8c32855 100644 --- a/crates/blockifier/src/fee/receipt_test.rs +++ b/crates/blockifier/src/fee/receipt_test.rs @@ -1,4 +1,5 @@ use rstest::{fixture, rstest}; +use starknet_api::execution_resources::GasVector; use starknet_api::transaction::{GasVectorComputationMode, L2ToL1Payload}; use starknet_api::{invoke_tx_args, nonce}; use starknet_types_core::felt::Felt; @@ -17,7 +18,7 @@ use crate::fee::gas_usage::{ get_log_message_to_l1_emissions_cost, get_message_segment_length, }; -use crate::fee::resources::{GasVector, StarknetResources, StateResources}; +use crate::fee::resources::{StarknetResources, StateResources}; use crate::state::cached_state::StateChangesCount; use crate::test_utils::contracts::FeatureContract; use crate::test_utils::initial_test_state::test_state; diff --git a/crates/blockifier/src/fee/resources.rs b/crates/blockifier/src/fee/resources.rs index e3312ef668c..9242572fd30 100644 --- a/crates/blockifier/src/fee/resources.rs +++ b/crates/blockifier/src/fee/resources.rs @@ -1,10 +1,8 @@ use cairo_vm::vm::runners::cairo_runner::ExecutionResources; -use serde::Serialize; use starknet_api::core::ContractAddress; -use starknet_api::execution_resources::GasAmount; -use starknet_api::transaction::{Fee, GasVectorComputationMode, Resource}; +use starknet_api::execution_resources::{GasAmount, GasVector}; +use starknet_api::transaction::GasVectorComputationMode; -use crate::blockifier::block::GasPricesForFeeType; use crate::execution::call_info::{EventSummary, ExecutionSummary}; use crate::fee::eth_gas_constants; use crate::fee::fee_utils::get_vm_resources_cost; @@ -293,92 +291,3 @@ impl MessageResources { + get_log_message_to_l1_emissions_cost(&self.l2_to_l1_payload_lengths) } } - -#[cfg_attr(feature = "transaction_serde", derive(serde::Deserialize))] -#[derive( - derive_more::Add, - derive_more::Sum, - derive_more::AddAssign, - Clone, - Copy, - Debug, - Default, - Eq, - PartialEq, - Serialize, -)] -pub struct GasVector { - pub l1_gas: GasAmount, - pub l1_data_gas: GasAmount, - pub l2_gas: GasAmount, -} - -impl GasVector { - pub fn from_l1_gas(l1_gas: GasAmount) -> Self { - Self { l1_gas, ..Default::default() } - } - - pub fn from_l1_data_gas(l1_data_gas: GasAmount) -> Self { - Self { l1_data_gas, ..Default::default() } - } - - pub fn from_l2_gas(l2_gas: GasAmount) -> Self { - Self { l2_gas, ..Default::default() } - } - - /// Computes the cost (in fee token units) of the gas vector (saturating on overflow). - pub fn saturated_cost(&self, gas_prices: &GasPricesForFeeType) -> Fee { - let mut sum = Fee(0); - for (gas, price, resource) in [ - (self.l1_gas, gas_prices.l1_gas_price, Resource::L1Gas), - (self.l1_data_gas, gas_prices.l1_data_gas_price, Resource::L1DataGas), - (self.l2_gas, gas_prices.l2_gas_price, Resource::L2Gas), - ] { - let cost = gas.checked_mul(price.get()).unwrap_or_else(|| { - log::warn!( - "{} cost overflowed: multiplication of gas amount ({}) by price per unit ({}) \ - resulted in overflow.", - resource, - gas, - price - ); - Fee(u128::MAX) - }); - sum = sum.checked_add(cost).unwrap_or_else(|| { - log::warn!( - "Total cost overflowed: addition of current sum ({}) and cost of {} ({}) \ - resulted in overflow.", - sum, - resource, - cost - ); - Fee(u128::MAX) - }); - } - sum - } - - /// Compute l1_gas estimation from gas_vector using the following formula: - /// One byte of data costs either 1 data gas (in blob mode) or 16 gas (in calldata - /// mode). For gas price GP and data gas price DGP, the discount for using blobs - /// would be DGP / (16 * GP). - /// X non-data-related gas consumption and Y bytes of data, in non-blob mode, would - /// cost (X + 16*Y) units of gas. Applying the discount ratio to the data-related - /// summand, we get total_gas = (X + Y * DGP / GP). - /// If this function is called with kzg_flag==false, then l1_data_gas==0, and this dicount - /// function does nothing. - pub fn to_discounted_l1_gas(&self, gas_prices: &GasPricesForFeeType) -> GasAmount { - let l1_data_gas_fee = self.l1_data_gas.nonzero_saturating_mul(gas_prices.l1_data_gas_price); - let l1_data_gas_in_l1_gas_units = - l1_data_gas_fee.checked_div_ceil(gas_prices.l1_gas_price).unwrap_or_else(|| { - log::warn!( - "Discounted L1 gas cost overflowed: division of L1 data fee ({}) by regular \ - L1 gas price ({}) resulted in overflow.", - l1_data_gas_fee, - gas_prices.l1_gas_price - ); - GasAmount::MAX - }); - self.l1_gas.saturating_add(l1_data_gas_in_l1_gas_units) - } -} diff --git a/crates/blockifier/src/test_utils.rs b/crates/blockifier/src/test_utils.rs index 4cff55bf93b..204c37c450a 100644 --- a/crates/blockifier/src/test_utils.rs +++ b/crates/blockifier/src/test_utils.rs @@ -16,7 +16,7 @@ use cairo_vm::types::builtin_name::BuiltinName; use cairo_vm::vm::runners::cairo_runner::ExecutionResources; use starknet_api::block::{GasPrice, NonzeroGasPrice}; use starknet_api::core::{ClassHash, ContractAddress, PatriciaKey}; -use starknet_api::execution_resources::GasAmount; +use starknet_api::execution_resources::{GasAmount, GasVector}; use starknet_api::state::StorageKey; use starknet_api::transaction::{ Calldata, @@ -33,7 +33,7 @@ use crate::execution::call_info::ExecutionSummary; use crate::execution::deprecated_syscalls::hint_processor::SyscallCounter; use crate::execution::entry_point::CallEntryPoint; use crate::execution::syscalls::SyscallSelector; -use crate::fee::resources::{GasVector, StarknetResources, StateResources}; +use crate::fee::resources::{StarknetResources, StateResources}; use crate::test_utils::contracts::FeatureContract; use crate::transaction::transaction_types::TransactionType; use crate::utils::{const_max, u128_from_usize}; diff --git a/crates/blockifier/src/transaction/account_transaction.rs b/crates/blockifier/src/transaction/account_transaction.rs index 3208558502d..2745625d8a3 100644 --- a/crates/blockifier/src/transaction/account_transaction.rs +++ b/crates/blockifier/src/transaction/account_transaction.rs @@ -1,6 +1,7 @@ use std::sync::Arc; use cairo_vm::vm::runners::cairo_runner::ExecutionResources; +use starknet_api::block::GasPriceVector; use starknet_api::calldata; use starknet_api::core::{ClassHash, ContractAddress, EntryPointSelector, Nonce}; use starknet_api::data_availability::DataAvailabilityMode; @@ -21,7 +22,6 @@ use starknet_api::transaction::{ use starknet_types_core::felt::Felt; use crate::abi::abi_utils::selector_from_name; -use crate::blockifier::block::GasPricesForFeeType; use crate::context::{BlockContext, TransactionContext}; use crate::execution::call_info::{CallInfo, Retdata}; use crate::execution::contract_class::ContractClass; @@ -328,7 +328,7 @@ impl AccountTransaction { l2_gas: l2_gas_resource_bounds, l1_data_gas: l1_data_gas_resource_bounds, }) => { - let GasPricesForFeeType { l1_gas_price, l1_data_gas_price, l2_gas_price } = + let GasPriceVector { l1_gas_price, l1_data_gas_price, l2_gas_price } = block_info.gas_prices.get_gas_prices_by_fee_type(fee_type); vec![ ( diff --git a/crates/blockifier/src/transaction/execution_flavors_test.rs b/crates/blockifier/src/transaction/execution_flavors_test.rs index c1f77cc400e..5dcc368a68f 100644 --- a/crates/blockifier/src/transaction/execution_flavors_test.rs +++ b/crates/blockifier/src/transaction/execution_flavors_test.rs @@ -2,7 +2,7 @@ use assert_matches::assert_matches; use pretty_assertions::assert_eq; use rstest::rstest; use starknet_api::core::ContractAddress; -use starknet_api::execution_resources::GasAmount; +use starknet_api::execution_resources::{GasAmount, GasVector}; use starknet_api::test_utils::invoke::InvokeTxArgs; use starknet_api::test_utils::NonceManager; use starknet_api::transaction::{ @@ -20,7 +20,6 @@ use starknet_types_core::felt::Felt; use crate::context::{BlockContext, ChainInfo}; use crate::execution::syscalls::SyscallSelector; use crate::fee::fee_utils::get_fee_by_gas_vector; -use crate::fee::resources::GasVector; use crate::state::cached_state::CachedState; use crate::state::state_api::StateReader; use crate::test_utils::contracts::FeatureContract; diff --git a/crates/blockifier/src/transaction/objects.rs b/crates/blockifier/src/transaction/objects.rs index 339593bebe5..404762e77d3 100644 --- a/crates/blockifier/src/transaction/objects.rs +++ b/crates/blockifier/src/transaction/objects.rs @@ -4,6 +4,7 @@ use cairo_vm::types::builtin_name::BuiltinName; use cairo_vm::vm::runners::cairo_runner::ExecutionResources; use starknet_api::core::{ContractAddress, Nonce}; use starknet_api::data_availability::DataAvailabilityMode; +use starknet_api::execution_resources::GasVector; use starknet_api::transaction::{ signed_tx_version, AccountDeploymentData, @@ -25,7 +26,6 @@ use crate::blockifier::block::BlockInfo; use crate::execution::call_info::{CallInfo, ExecutionSummary}; use crate::fee::fee_utils::get_fee_by_gas_vector; use crate::fee::receipt::TransactionReceipt; -use crate::fee::resources::GasVector; use crate::transaction::errors::{TransactionExecutionError, TransactionPreValidationError}; #[cfg(test)] diff --git a/crates/blockifier/src/transaction/transactions_test.rs b/crates/blockifier/src/transaction/transactions_test.rs index 4db197658cb..414b1700fd4 100644 --- a/crates/blockifier/src/transaction/transactions_test.rs +++ b/crates/blockifier/src/transaction/transactions_test.rs @@ -8,8 +8,10 @@ use num_bigint::BigUint; use num_traits::Pow; use pretty_assertions::assert_eq; use rstest::{fixture, rstest}; +use starknet_api::block::GasPriceVector; use starknet_api::core::{ChainId, ClassHash, ContractAddress, EthAddress, Nonce, PatriciaKey}; use starknet_api::deprecated_contract_class::EntryPointType; +use starknet_api::execution_resources::GasVector; use starknet_api::state::StorageKey; use starknet_api::test_utils::invoke::InvokeTxArgs; use starknet_api::test_utils::NonceManager; @@ -50,7 +52,6 @@ use crate::abi::abi_utils::{ }; use crate::abi::constants as abi_constants; use crate::abi::sierra_types::next_storage_key; -use crate::blockifier::block::GasPricesForFeeType; use crate::context::{BlockContext, ChainInfo, FeeTokenAddresses, TransactionContext}; use crate::execution::call_info::{ CallExecution, @@ -75,7 +76,6 @@ use crate::fee::gas_usage::{ use crate::fee::receipt::TransactionReceipt; use crate::fee::resources::{ ComputationResources, - GasVector, StarknetResources, StateResources, TransactionResources, @@ -972,7 +972,7 @@ fn test_insufficient_new_resource_bounds( let tx = &account_invoke_tx(valid_invoke_tx_args.clone()); // V3 transaction. - let GasPricesForFeeType { + let GasPriceVector { l1_gas_price: actual_strk_l1_gas_price, l1_data_gas_price: actual_strk_l1_data_gas_price, l2_gas_price: actual_strk_l2_gas_price, diff --git a/crates/native_blockifier/src/py_block_executor.rs b/crates/native_blockifier/src/py_block_executor.rs index 59538aae360..c7f2ac42d73 100644 --- a/crates/native_blockifier/src/py_block_executor.rs +++ b/crates/native_blockifier/src/py_block_executor.rs @@ -7,7 +7,6 @@ use blockifier::bouncer::BouncerConfig; use blockifier::context::{BlockContext, ChainInfo, FeeTokenAddresses}; use blockifier::execution::call_info::CallInfo; use blockifier::fee::receipt::TransactionReceipt; -use blockifier::fee::resources::GasVector; use blockifier::state::global_cache::GlobalContractCache; use blockifier::transaction::objects::{ExecutionResourcesTraits, TransactionExecutionInfo}; use blockifier::transaction::transaction_execution::Transaction; @@ -19,6 +18,7 @@ use pyo3::{FromPyObject, PyAny, Python}; use serde::Serialize; use starknet_api::block::BlockNumber; use starknet_api::core::{ChainId, ContractAddress}; +use starknet_api::execution_resources::GasVector; use starknet_api::transaction::Fee; use starknet_types_core::felt::Felt; diff --git a/crates/papyrus_execution/src/objects.rs b/crates/papyrus_execution/src/objects.rs index bbef0bf51ff..cc14739f771 100644 --- a/crates/papyrus_execution/src/objects.rs +++ b/crates/papyrus_execution/src/objects.rs @@ -9,7 +9,6 @@ use blockifier::execution::call_info::{ Retdata as BlockifierRetdata, }; use blockifier::execution::entry_point::CallType as BlockifierCallType; -use blockifier::fee::resources::GasVector; use blockifier::transaction::objects::{FeeType, TransactionExecutionInfo}; use cairo_vm::types::builtin_name::BuiltinName; use cairo_vm::vm::runners::cairo_runner::ExecutionResources as VmExecutionResources; @@ -36,6 +35,7 @@ use starknet_api::deprecated_contract_class::EntryPointType; use starknet_api::execution_resources::{ Builtin, ExecutionResources, + GasVector, GasVector as StarknetApiGasVector, }; use starknet_api::state::ThinStateDiff; diff --git a/crates/starknet_api/Cargo.toml b/crates/starknet_api/Cargo.toml index 4672191a419..e6fa5200bbf 100644 --- a/crates/starknet_api/Cargo.toml +++ b/crates/starknet_api/Cargo.toml @@ -16,6 +16,7 @@ derive_more.workspace = true hex.workspace = true indexmap = { workspace = true, features = ["serde"] } itertools.workspace = true +log.workspace = true num-bigint.workspace = true pretty_assertions.workspace = true primitive-types = { workspace = true, features = ["serde"] } diff --git a/crates/starknet_api/src/block.rs b/crates/starknet_api/src/block.rs index 069ab6f53ba..c922cec7500 100644 --- a/crates/starknet_api/src/block.rs +++ b/crates/starknet_api/src/block.rs @@ -344,6 +344,13 @@ macro_rules! impl_try_from_uint_for_nonzero_gas_price { impl_try_from_uint_for_nonzero_gas_price!(u8, u16, u32, u64, u128); +#[derive(Clone, Debug)] +pub struct GasPriceVector { + pub l1_gas_price: NonzeroGasPrice, + pub l1_data_gas_price: NonzeroGasPrice, + pub l2_gas_price: NonzeroGasPrice, +} + /// The timestamp of a [Block](`crate::block::Block`). #[derive( Debug, Default, Copy, Clone, Eq, PartialEq, Hash, Deserialize, Serialize, PartialOrd, Ord, diff --git a/crates/starknet_api/src/execution_resources.rs b/crates/starknet_api/src/execution_resources.rs index 43a0352ebc9..c29ce281f9a 100644 --- a/crates/starknet_api/src/execution_resources.rs +++ b/crates/starknet_api/src/execution_resources.rs @@ -4,8 +4,8 @@ use serde::{Deserialize, Serialize}; use starknet_types_core::felt::Felt; use strum_macros::EnumIter; -use crate::block::{GasPrice, NonzeroGasPrice}; -use crate::transaction::Fee; +use crate::block::{GasPrice, GasPriceVector, NonzeroGasPrice}; +use crate::transaction::{Fee, Resource}; #[derive( derive_more::Add, @@ -70,7 +70,19 @@ impl GasAmount { } } -#[derive(Debug, Default, Deserialize, Serialize, Clone, Eq, PartialEq)] +#[derive( + derive_more::Add, + derive_more::Sum, + derive_more::AddAssign, + Clone, + Copy, + Debug, + Default, + Eq, + PartialEq, + Deserialize, + Serialize, +)] pub struct GasVector { pub l1_gas: GasAmount, pub l1_data_gas: GasAmount, @@ -78,6 +90,76 @@ pub struct GasVector { pub l2_gas: GasAmount, } +impl GasVector { + pub fn from_l1_gas(l1_gas: GasAmount) -> Self { + Self { l1_gas, ..Default::default() } + } + + pub fn from_l1_data_gas(l1_data_gas: GasAmount) -> Self { + Self { l1_data_gas, ..Default::default() } + } + + pub fn from_l2_gas(l2_gas: GasAmount) -> Self { + Self { l2_gas, ..Default::default() } + } + + /// Computes the cost (in fee token units) of the gas vector (saturating on overflow). + pub fn saturated_cost(&self, gas_prices: &GasPriceVector) -> Fee { + let mut sum = Fee(0); + for (gas, price, resource) in [ + (self.l1_gas, gas_prices.l1_gas_price, Resource::L1Gas), + (self.l1_data_gas, gas_prices.l1_data_gas_price, Resource::L1DataGas), + (self.l2_gas, gas_prices.l2_gas_price, Resource::L2Gas), + ] { + let cost = gas.checked_mul(price.get()).unwrap_or_else(|| { + log::warn!( + "{} cost overflowed: multiplication of gas amount ({}) by price per unit ({}) \ + resulted in overflow.", + resource, + gas, + price + ); + Fee(u128::MAX) + }); + sum = sum.checked_add(cost).unwrap_or_else(|| { + log::warn!( + "Total cost overflowed: addition of current sum ({}) and cost of {} ({}) \ + resulted in overflow.", + sum, + resource, + cost + ); + Fee(u128::MAX) + }); + } + sum + } + + /// Compute l1_gas estimation from gas_vector using the following formula: + /// One byte of data costs either 1 data gas (in blob mode) or 16 gas (in calldata + /// mode). For gas price GP and data gas price DGP, the discount for using blobs + /// would be DGP / (16 * GP). + /// X non-data-related gas consumption and Y bytes of data, in non-blob mode, would + /// cost (X + 16*Y) units of gas. Applying the discount ratio to the data-related + /// summand, we get total_gas = (X + Y * DGP / GP). + /// If this function is called with kzg_flag==false, then l1_data_gas==0, and this dicount + /// function does nothing. + pub fn to_discounted_l1_gas(&self, gas_prices: &GasPriceVector) -> GasAmount { + let l1_data_gas_fee = self.l1_data_gas.nonzero_saturating_mul(gas_prices.l1_data_gas_price); + let l1_data_gas_in_l1_gas_units = + l1_data_gas_fee.checked_div_ceil(gas_prices.l1_gas_price).unwrap_or_else(|| { + log::warn!( + "Discounted L1 gas cost overflowed: division of L1 data fee ({}) by regular \ + L1 gas price ({}) resulted in overflow.", + l1_data_gas_fee, + gas_prices.l1_gas_price + ); + GasAmount::MAX + }); + self.l1_gas.saturating_add(l1_data_gas_in_l1_gas_units) + } +} + /// The execution resources used by a transaction. #[derive(Debug, Default, Deserialize, Serialize, Clone, Eq, PartialEq)] pub struct ExecutionResources { From 25949ac15e6a8c5699a9d1858e3428ca0e643eb3 Mon Sep 17 00:00:00 2001 From: Yoni <78365039+Yoni-Starkware@users.noreply.github.com> Date: Wed, 9 Oct 2024 15:05:00 +0300 Subject: [PATCH 34/57] chore(blockifier): remove concurrency feature (#1262) --- crates/blockifier/Cargo.toml | 1 - crates/blockifier/src/blockifier/config.rs | 18 +++++++----------- .../src/blockifier/transaction_executor.rs | 17 +---------------- .../blockifier/transaction_executor_test.rs | 4 ++-- .../src/blockifier/transfers_flow_test.rs | 10 ++++++++-- crates/blockifier/src/lib.rs | 1 - crates/blockifier/src/state/cached_state.rs | 3 +-- .../src/test_utils/transfers_generator.rs | 12 +----------- crates/native_blockifier/Cargo.toml | 2 +- .../native_blockifier/src/py_block_executor.rs | 2 +- 10 files changed, 22 insertions(+), 48 deletions(-) diff --git a/crates/blockifier/Cargo.toml b/crates/blockifier/Cargo.toml index df7f032b12f..32da5f8099e 100644 --- a/crates/blockifier/Cargo.toml +++ b/crates/blockifier/Cargo.toml @@ -10,7 +10,6 @@ description = "The transaction-executing component in the Starknet sequencer." workspace = true [features] -concurrency = [] jemalloc = ["dep:tikv-jemallocator"] testing = ["rand", "rstest", "starknet_api/testing"] transaction_serde = [] diff --git a/crates/blockifier/src/blockifier/config.rs b/crates/blockifier/src/blockifier/config.rs index 6de9f5ab718..8f461aab88d 100644 --- a/crates/blockifier/src/blockifier/config.rs +++ b/crates/blockifier/src/blockifier/config.rs @@ -4,8 +4,8 @@ pub struct TransactionExecutorConfig { } impl TransactionExecutorConfig { #[cfg(any(test, feature = "testing"))] - pub fn create_for_testing() -> Self { - Self { concurrency_config: ConcurrencyConfig::create_for_testing() } + pub fn create_for_testing(concurrency_enabled: bool) -> Self { + Self { concurrency_config: ConcurrencyConfig::create_for_testing(concurrency_enabled) } } } @@ -15,16 +15,12 @@ pub struct ConcurrencyConfig { pub n_workers: usize, pub chunk_size: usize, } -#[cfg(all(any(test, feature = "testing"), not(feature = "concurrency")))] -impl ConcurrencyConfig { - pub fn create_for_testing() -> Self { - Self { enabled: false, n_workers: 0, chunk_size: 0 } - } -} -#[cfg(all(any(test, feature = "testing"), feature = "concurrency"))] impl ConcurrencyConfig { - pub fn create_for_testing() -> Self { - Self { enabled: true, n_workers: 4, chunk_size: 64 } + pub fn create_for_testing(concurrency_enabled: bool) -> Self { + if concurrency_enabled { + return Self { enabled: true, n_workers: 4, chunk_size: 64 }; + } + Self { enabled: false, n_workers: 0, chunk_size: 0 } } } diff --git a/crates/blockifier/src/blockifier/transaction_executor.rs b/crates/blockifier/src/blockifier/transaction_executor.rs index c9a9c9c569f..78de3a7cfcd 100644 --- a/crates/blockifier/src/blockifier/transaction_executor.rs +++ b/crates/blockifier/src/blockifier/transaction_executor.rs @@ -1,11 +1,6 @@ -#[cfg(feature = "concurrency")] use std::collections::{HashMap, HashSet}; -#[cfg(feature = "concurrency")] use std::panic::{self, catch_unwind, AssertUnwindSafe}; -#[cfg(feature = "concurrency")] -use std::sync::Arc; -#[cfg(feature = "concurrency")] -use std::sync::Mutex; +use std::sync::{Arc, Mutex}; use itertools::FoldWhile::{Continue, Done}; use itertools::Itertools; @@ -15,7 +10,6 @@ use thiserror::Error; use crate::blockifier::block::{pre_process_block, BlockNumberHashPair}; use crate::blockifier::config::TransactionExecutorConfig; use crate::bouncer::{Bouncer, BouncerWeights}; -#[cfg(feature = "concurrency")] use crate::concurrency::worker_logic::WorkerExecutor; use crate::context::BlockContext; use crate::state::cached_state::{CachedState, CommitmentStateDiff, TransactionalState}; @@ -144,14 +138,6 @@ impl TransactionExecutor { results } - #[cfg(not(feature = "concurrency"))] - pub fn execute_chunk( - &mut self, - _chunk: &[Transaction], - ) -> Vec> { - unimplemented!() - } - /// Returns the state diff, a list of contract class hash with the corresponding list of /// visited segment values and the block weights. pub fn finalize( @@ -229,7 +215,6 @@ impl TransactionExecutor { } } - #[cfg(feature = "concurrency")] pub fn execute_chunk( &mut self, chunk: &[Transaction], diff --git a/crates/blockifier/src/blockifier/transaction_executor_test.rs b/crates/blockifier/src/blockifier/transaction_executor_test.rs index 955e5c830f2..b6987122e3d 100644 --- a/crates/blockifier/src/blockifier/transaction_executor_test.rs +++ b/crates/blockifier/src/blockifier/transaction_executor_test.rs @@ -280,8 +280,8 @@ fn test_bouncing(#[case] initial_bouncer_weights: BouncerWeights, #[case] n_even } #[rstest] -fn test_execute_txs_bouncing() { - let config = TransactionExecutorConfig::create_for_testing(); +fn test_execute_txs_bouncing(#[values(true, false)] concurrency_enabled: bool) { + let config = TransactionExecutorConfig::create_for_testing(concurrency_enabled); let max_n_events_in_block = 10; let block_context = BlockContext::create_for_bouncer_testing(max_n_events_in_block); diff --git a/crates/blockifier/src/blockifier/transfers_flow_test.rs b/crates/blockifier/src/blockifier/transfers_flow_test.rs index 0e47383651d..94cd27518c6 100644 --- a/crates/blockifier/src/blockifier/transfers_flow_test.rs +++ b/crates/blockifier/src/blockifier/transfers_flow_test.rs @@ -1,13 +1,19 @@ +use rstest::rstest; + +use crate::blockifier::config::ConcurrencyConfig; use crate::test_utils::transfers_generator::{ RecipientGeneratorType, TransfersGenerator, TransfersGeneratorConfig, }; -#[test] -pub fn transfers_flow_test() { +#[rstest] +#[case::concurrency_enabled(ConcurrencyConfig{enabled: true, n_workers: 4, chunk_size: 100})] +#[case::concurrency_disabled(ConcurrencyConfig{enabled: false, n_workers: 0, chunk_size: 0})] +pub fn transfers_flow_test(#[case] concurrency_config: ConcurrencyConfig) { let transfers_generator_config = TransfersGeneratorConfig { recipient_generator_type: RecipientGeneratorType::DisjointFromSenders, + concurrency_config, ..Default::default() }; assert!( diff --git a/crates/blockifier/src/lib.rs b/crates/blockifier/src/lib.rs index 577f2502dea..8129f9f65bc 100644 --- a/crates/blockifier/src/lib.rs +++ b/crates/blockifier/src/lib.rs @@ -12,7 +12,6 @@ static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc; pub mod abi; pub mod blockifier; pub mod bouncer; -#[cfg(feature = "concurrency")] pub mod concurrency; pub mod context; pub mod execution; diff --git a/crates/blockifier/src/state/cached_state.rs b/crates/blockifier/src/state/cached_state.rs index e50c2afbbf9..b49e72ed328 100644 --- a/crates/blockifier/src/state/cached_state.rs +++ b/crates/blockifier/src/state/cached_state.rs @@ -314,8 +314,7 @@ impl From for IndexMap> } } -#[cfg_attr(any(feature = "testing", test), derive(Clone))] -#[derive(Debug, Default, PartialEq, Eq)] +#[derive(Clone, Debug, Default, PartialEq, Eq)] pub struct StateMaps { pub nonces: HashMap, pub class_hashes: HashMap, diff --git a/crates/blockifier/src/test_utils/transfers_generator.rs b/crates/blockifier/src/test_utils/transfers_generator.rs index 713e4120e45..c6d4f801956 100644 --- a/crates/blockifier/src/test_utils/transfers_generator.rs +++ b/crates/blockifier/src/test_utils/transfers_generator.rs @@ -25,12 +25,6 @@ const RANDOMIZATION_SEED: u64 = 0; const CAIRO_VERSION: CairoVersion = CairoVersion::Cairo0; const TRANSACTION_VERSION: TransactionVersion = TransactionVersion(Felt::THREE); const RECIPIENT_GENERATOR_TYPE: RecipientGeneratorType = RecipientGeneratorType::RoundRobin; -#[cfg(feature = "concurrency")] -const CONCURRENCY_MODE: bool = true; -#[cfg(not(feature = "concurrency"))] -const CONCURRENCY_MODE: bool = false; -const N_WORKERS: usize = 4; -const CHUNK_SIZE: usize = 100; pub struct TransfersGeneratorConfig { pub n_accounts: u16, @@ -55,11 +49,7 @@ impl Default for TransfersGeneratorConfig { cairo_version: CAIRO_VERSION, tx_version: TRANSACTION_VERSION, recipient_generator_type: RECIPIENT_GENERATOR_TYPE, - concurrency_config: ConcurrencyConfig { - enabled: CONCURRENCY_MODE, - n_workers: N_WORKERS, - chunk_size: CHUNK_SIZE, - }, + concurrency_config: ConcurrencyConfig::default(), } } } diff --git a/crates/native_blockifier/Cargo.toml b/crates/native_blockifier/Cargo.toml index 488db861924..63b101f2684 100644 --- a/crates/native_blockifier/Cargo.toml +++ b/crates/native_blockifier/Cargo.toml @@ -27,7 +27,7 @@ crate-type = ["cdylib"] [dependencies] # TODO(Dori, 1/1/2025): Add the "jemalloc" feature to the blockifier crate when possible. -blockifier = { workspace = true, features = ["concurrency", "testing"] } +blockifier = { workspace = true, features = ["testing"] } cairo-lang-starknet-classes.workspace = true cairo-vm.workspace = true indexmap.workspace = true diff --git a/crates/native_blockifier/src/py_block_executor.rs b/crates/native_blockifier/src/py_block_executor.rs index c7f2ac42d73..7bf28040a1a 100644 --- a/crates/native_blockifier/src/py_block_executor.rs +++ b/crates/native_blockifier/src/py_block_executor.rs @@ -415,7 +415,7 @@ impl PyBlockExecutor { use blockifier::state::global_cache::GLOBAL_CONTRACT_CACHE_SIZE_FOR_TEST; Self { bouncer_config: BouncerConfig::max(), - tx_executor_config: TransactionExecutorConfig::create_for_testing(), + tx_executor_config: TransactionExecutorConfig::create_for_testing(true), storage: Box::new(storage), chain_info: ChainInfo::default(), versioned_constants: VersionedConstants::latest_constants().clone(), From 0a090fa5a508ae7a0533ada473c70e0a74662709 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 15:38:30 +0300 Subject: [PATCH 35/57] feat(starknet_api): resource bounds struct now has typed fields (#1180) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1180) --- .../blockifier/src/execution/entry_point.rs | 2 +- .../syscall_tests/get_execution_info.rs | 14 +++--- crates/blockifier/src/fee/fee_checks.rs | 12 ++--- crates/blockifier/src/fee/fee_utils.rs | 8 ++-- .../src/transaction/account_transaction.rs | 8 ++-- .../transaction/account_transactions_test.rs | 29 ++++++----- crates/blockifier/src/transaction/errors.rs | 28 +++++------ .../blockifier/src/transaction/test_utils.rs | 18 +++---- .../src/transaction/transactions_test.rs | 26 +++++----- .../stateful_transaction_validator_test.rs | 6 ++- .../src/stateless_transaction_validator.rs | 6 ++- crates/mempool/src/mempool.rs | 5 +- crates/mempool/src/mempool_test.rs | 9 ++-- crates/mempool/src/transaction_queue.rs | 12 +++-- .../src/transaction_queue_test_utils.rs | 7 ++- .../src/starknet_api_test_utils.rs | 16 ++++--- .../native_blockifier/src/py_transaction.rs | 6 ++- .../src/converters/consensus_test.rs | 3 +- .../src/converters/rpc_transaction_test.rs | 11 +++-- .../src/converters/transaction.rs | 11 +++-- .../src/converters/transaction_test.rs | 18 +++++-- .../src/serialization/serializers.rs | 4 +- crates/papyrus_test_utils/src/lib.rs | 4 +- crates/starknet_api/src/block.rs | 7 +++ .../starknet_api/src/rpc_transaction_test.rs | 8 ++-- crates/starknet_api/src/transaction.rs | 48 ++++++++++--------- crates/starknet_api/src/transaction_hash.rs | 4 +- 27 files changed, 192 insertions(+), 138 deletions(-) diff --git a/crates/blockifier/src/execution/entry_point.rs b/crates/blockifier/src/execution/entry_point.rs index 1376dba8d07..8c9cf87d795 100644 --- a/crates/blockifier/src/execution/entry_point.rs +++ b/crates/blockifier/src/execution/entry_point.rs @@ -282,7 +282,7 @@ impl EntryPointExecutionContext { TransactionInfo::Deprecated(context) => context.max_fee.saturating_div( block_info.gas_prices.get_l1_gas_price_by_fee_type(&tx_info.fee_type()), ), - TransactionInfo::Current(context) => context.l1_resource_bounds().max_amount.into(), + TransactionInfo::Current(context) => context.l1_resource_bounds().max_amount, }; // Use saturating upper bound to avoid overflow. This is safe because the upper bound is diff --git a/crates/blockifier/src/execution/syscalls/syscall_tests/get_execution_info.rs b/crates/blockifier/src/execution/syscalls/syscall_tests/get_execution_info.rs index 51ef403aa8a..ecd49fc9dd0 100644 --- a/crates/blockifier/src/execution/syscalls/syscall_tests/get_execution_info.rs +++ b/crates/blockifier/src/execution/syscalls/syscall_tests/get_execution_info.rs @@ -1,7 +1,9 @@ use cairo_vm::Felt252; use num_traits::Pow; +use starknet_api::block::GasPrice; use starknet_api::core::ChainId; use starknet_api::data_availability::DataAvailabilityMode; +use starknet_api::execution_resources::GasAmount; use starknet_api::transaction::{ AccountDeploymentData, Calldata, @@ -143,8 +145,8 @@ fn test_get_execution_info( let nonce = nonce!(3_u16); let sender_address = test_contract_address; - let max_amount = Fee(13); - let max_price_per_unit = Fee(61); + let max_amount = GasAmount(13); + let max_price_per_unit = GasPrice(61); let expected_resource_bounds: Vec = match (test_contract, version) { (FeatureContract::LegacyTestContract, _) => vec![], @@ -154,8 +156,8 @@ fn test_get_execution_info( (_, _) => vec![ Felt::from(2u32), // Length of ResourceBounds array. felt!(Resource::L1Gas.to_hex()), // Resource. - felt!(max_amount.0), // Max amount. - felt!(max_price_per_unit.0), // Max price per unit. + max_amount.into(), // Max amount. + max_price_per_unit.into(), // Max price per unit. felt!(Resource::L2Gas.to_hex()), // Resource. Felt::ZERO, // Max amount. Felt::ZERO, // Max price per unit. @@ -209,8 +211,8 @@ fn test_get_execution_info( ..Default::default() }, resource_bounds: ValidResourceBounds::L1Gas(ResourceBounds { - max_amount: max_amount.0.try_into().expect("Failed to convert u128 to u64."), - max_price_per_unit: max_price_per_unit.0, + max_amount, + max_price_per_unit, }), tip: Tip::default(), nonce_data_availability_mode: DataAvailabilityMode::L1, diff --git a/crates/blockifier/src/fee/fee_checks.rs b/crates/blockifier/src/fee/fee_checks.rs index 383f7584338..b3d6ff20328 100644 --- a/crates/blockifier/src/fee/fee_checks.rs +++ b/crates/blockifier/src/fee/fee_checks.rs @@ -75,7 +75,7 @@ impl FeeCheckReport { match &tx_context.tx_info { TransactionInfo::Current(info) => get_fee_by_gas_vector( &tx_context.block_context.block_info, - GasVector::from_l1_gas(info.l1_resource_bounds().max_amount.into()), + GasVector::from_l1_gas(info.l1_resource_bounds().max_amount), &FeeType::Strk, ), TransactionInfo::Deprecated(context) => context.max_fee, @@ -152,9 +152,9 @@ impl FeeCheckReport { gas_vector: &GasVector, ) -> FeeCheckResult<()> { for (resource, max_amount, actual_amount) in [ - (L1Gas, all_resource_bounds.l1_gas.max_amount.into(), gas_vector.l1_gas), - (L2Gas, all_resource_bounds.l2_gas.max_amount.into(), gas_vector.l2_gas), - (L1DataGas, all_resource_bounds.l1_data_gas.max_amount.into(), gas_vector.l1_data_gas), + (L1Gas, all_resource_bounds.l1_gas.max_amount, gas_vector.l1_gas), + (L2Gas, all_resource_bounds.l2_gas.max_amount, gas_vector.l2_gas), + (L1DataGas, all_resource_bounds.l1_data_gas.max_amount, gas_vector.l1_data_gas), ] { if max_amount < actual_amount { return Err(FeeCheckError::MaxGasAmountExceeded { @@ -175,10 +175,10 @@ impl FeeCheckReport { ) -> FeeCheckResult<()> { let total_discounted_gas_used = gas_vector.to_discounted_l1_gas(tx_context.get_gas_prices()); - if total_discounted_gas_used > l1_bounds.max_amount.into() { + if total_discounted_gas_used > l1_bounds.max_amount { return Err(FeeCheckError::MaxGasAmountExceeded { resource: L1Gas, - max_amount: l1_bounds.max_amount.into(), + max_amount: l1_bounds.max_amount, actual_amount: total_discounted_gas_used, }); } diff --git a/crates/blockifier/src/fee/fee_utils.rs b/crates/blockifier/src/fee/fee_utils.rs index 4646b50d5d0..5cc9dda5205 100644 --- a/crates/blockifier/src/fee/fee_utils.rs +++ b/crates/blockifier/src/fee/fee_utils.rs @@ -115,7 +115,7 @@ pub fn verify_can_pay_committed_bounds( // Sender will not be charged by `max_price_per_unit`, but this check should not // depend on the current gas price. { - Fee(u128::from(l1_gas.max_amount) * l1_gas.max_price_per_unit) + l1_gas.max_amount.saturating_mul(l1_gas.max_price_per_unit) } // TODO!(Aner): add tests AllResources(AllResourceBounds { l1_gas, l2_gas, l1_data_gas }) => { @@ -123,9 +123,9 @@ pub fn verify_can_pay_committed_bounds( // of the different resources. // The Sender will not be charged by`max_price_per_unit`, but this check should // not depend on the current gas price - Fee(u128::from(l1_gas.max_amount) * l1_gas.max_price_per_unit - + u128::from(l1_data_gas.max_amount) * l1_data_gas.max_price_per_unit - + u128::from(l2_gas.max_amount) * l2_gas.max_price_per_unit) + l1_gas.max_amount.saturating_mul(l1_gas.max_price_per_unit) + + l1_data_gas.max_amount.saturating_mul(l1_data_gas.max_price_per_unit) + + l2_gas.max_amount.saturating_mul(l2_gas.max_price_per_unit) } } } diff --git a/crates/blockifier/src/transaction/account_transaction.rs b/crates/blockifier/src/transaction/account_transaction.rs index 2745625d8a3..14e7622e74a 100644 --- a/crates/blockifier/src/transaction/account_transaction.rs +++ b/crates/blockifier/src/transaction/account_transaction.rs @@ -357,18 +357,18 @@ impl AccountTransaction { { // TODO(Aner): refactor to indicate both amount and price are too low. // TODO(Aner): refactor to return all amounts that are too low. - if minimal_gas_amount > resource_bounds.max_amount.into() { + if minimal_gas_amount > resource_bounds.max_amount { return Err(TransactionFeeError::MaxGasAmountTooLow { resource, - max_gas_amount: resource_bounds.max_amount.into(), + max_gas_amount: resource_bounds.max_amount, minimal_gas_amount, })?; } // TODO(Aner): refactor to return all prices that are too low. - if resource_bounds.max_price_per_unit < actual_gas_price.get().0 { + if resource_bounds.max_price_per_unit < actual_gas_price.get() { return Err(TransactionFeeError::MaxGasPriceTooLow { resource, - max_gas_price: resource_bounds.max_price_per_unit.into(), + max_gas_price: resource_bounds.max_price_per_unit, actual_gas_price: actual_gas_price.into(), })?; } diff --git a/crates/blockifier/src/transaction/account_transactions_test.rs b/crates/blockifier/src/transaction/account_transactions_test.rs index a7f19ff2bb4..62e48972c68 100644 --- a/crates/blockifier/src/transaction/account_transactions_test.rs +++ b/crates/blockifier/src/transaction/account_transactions_test.rs @@ -5,6 +5,7 @@ use cairo_vm::types::builtin_name::BuiltinName; use cairo_vm::vm::runners::cairo_runner::ResourceTracker; use pretty_assertions::assert_eq; use rstest::rstest; +use starknet_api::block::GasPrice; use starknet_api::core::{calculate_contract_address, ClassHash, ContractAddress, PatriciaKey}; use starknet_api::execution_resources::GasAmount; use starknet_api::hash::StarkHash; @@ -200,31 +201,29 @@ fn test_assert_actual_fee_in_bounds( #[case] positive_flow: bool, #[case] deprecated_tx: bool, ) { - let actual_fee_offset = if positive_flow { 0 } else { 1 }; + let actual_fee_offset = Fee(if positive_flow { 0 } else { 1 }); if deprecated_tx { - let max_fee = 100; - let tx = account_invoke_tx(invoke_tx_args! { - max_fee: Fee(max_fee), - version: TransactionVersion::ONE, - }); + let max_fee = Fee(100); + let tx = account_invoke_tx(invoke_tx_args! { max_fee, version: TransactionVersion::ONE }); let context = Arc::new(block_context.to_tx_context(&tx)); - AccountTransaction::assert_actual_fee_in_bounds(&context, Fee(max_fee + actual_fee_offset)); + AccountTransaction::assert_actual_fee_in_bounds(&context, max_fee + actual_fee_offset); } else { // All resources. - let l1_gas = ResourceBounds { max_amount: 2, max_price_per_unit: 3 }; - let l2_gas = ResourceBounds { max_amount: 4, max_price_per_unit: 5 }; - let l1_data_gas = ResourceBounds { max_amount: 6, max_price_per_unit: 7 }; + let l1_gas = ResourceBounds { max_amount: GasAmount(2), max_price_per_unit: GasPrice(3) }; + let l2_gas = ResourceBounds { max_amount: GasAmount(4), max_price_per_unit: GasPrice(5) }; + let l1_data_gas = + ResourceBounds { max_amount: GasAmount(6), max_price_per_unit: GasPrice(7) }; let all_resource_bounds = ValidResourceBounds::AllResources(AllResourceBounds { l1_gas, l2_gas, l1_data_gas }); - let all_resource_fee = u128::from(l1_gas.max_amount) * l1_gas.max_price_per_unit - + u128::from(l2_gas.max_amount) * l2_gas.max_price_per_unit - + u128::from(l1_data_gas.max_amount) * l1_data_gas.max_price_per_unit + let all_resource_fee = l1_gas.max_amount.checked_mul(l1_gas.max_price_per_unit).unwrap() + + l2_gas.max_amount.checked_mul(l2_gas.max_price_per_unit).unwrap() + + l1_data_gas.max_amount.checked_mul(l1_data_gas.max_price_per_unit).unwrap() + actual_fee_offset; // L1 resources. let l1_resource_bounds = ValidResourceBounds::L1Gas(l1_gas); let l1_resource_fee = - u128::from(l1_gas.max_amount) * l1_gas.max_price_per_unit + actual_fee_offset; + l1_gas.max_amount.checked_mul(l1_gas.max_price_per_unit).unwrap() + actual_fee_offset; for (bounds, actual_fee) in [(all_resource_bounds, all_resource_fee), (l1_resource_bounds, l1_resource_fee)] @@ -234,7 +233,7 @@ fn test_assert_actual_fee_in_bounds( version: TransactionVersion::THREE, }); let context = Arc::new(block_context.to_tx_context(&tx)); - AccountTransaction::assert_actual_fee_in_bounds(&context, Fee(actual_fee)); + AccountTransaction::assert_actual_fee_in_bounds(&context, actual_fee); } } } diff --git a/crates/blockifier/src/transaction/errors.rs b/crates/blockifier/src/transaction/errors.rs index 6c2ae269d53..81f02f14e17 100644 --- a/crates/blockifier/src/transaction/errors.rs +++ b/crates/blockifier/src/transaction/errors.rs @@ -28,28 +28,28 @@ pub enum TransactionFeeError { #[error("Actual fee ({}) exceeded paid fee on L1 ({}).", actual_fee.0, paid_fee.0)] InsufficientFee { paid_fee: Fee, actual_fee: Fee }, #[error( - "Resources bounds (l1 gas max amount: {l1_max_amount}, l1 gas max price: {l1_max_price}, \ - l1 data max amount: {l1_data_max_amount}, l1 data max price: {l1_data_max_price}, l2 gas \ - max amount: {l2_max_amount}, l2 gas max price: {l2_max_price}) exceed balance \ - ({balance})." + "Resources bounds (l1 gas max amount: {l1_max_amount:?}, l1 gas max price: \ + {l1_max_price:?}, l1 data max amount: {l1_data_max_amount:?}, l1 data max price: \ + {l1_data_max_price:?}, l2 gas max amount: {l2_max_amount:?}, l2 gas max price: \ + {l2_max_price:?}) exceed balance ({balance})." )] ResourcesBoundsExceedBalance { - l1_max_amount: u64, - l1_max_price: u128, - l1_data_max_amount: u64, - l1_data_max_price: u128, - l2_max_amount: u64, - l2_max_price: u128, + l1_max_amount: GasAmount, + l1_max_price: GasPrice, + l1_data_max_amount: GasAmount, + l1_data_max_price: GasPrice, + l2_max_amount: GasAmount, + l2_max_price: GasPrice, balance: BigUint, }, #[error( - "Resource {resource} bounds (max amount: {max_amount}, max price): {max_price}) exceed \ - balance ({balance})." + "Resource {resource} bounds (max amount: {max_amount:?}, max price): {max_price:?}) \ + exceed balance ({balance})." )] GasBoundsExceedBalance { resource: Resource, - max_amount: u64, - max_price: u128, + max_amount: GasAmount, + max_price: GasPrice, balance: BigUint, }, #[error("Max fee ({}) exceeds balance ({balance}).", max_fee.0, )] diff --git a/crates/blockifier/src/transaction/test_utils.rs b/crates/blockifier/src/transaction/test_utils.rs index 4540acd7d2c..276217f0063 100644 --- a/crates/blockifier/src/transaction/test_utils.rs +++ b/crates/blockifier/src/transaction/test_utils.rs @@ -329,11 +329,11 @@ pub fn run_invoke_tx( /// Creates a `ResourceBoundsMapping` with the given `max_amount` and `max_price` for L1 gas limits. /// No guarantees on the values of the other resources bounds. // TODO: Check usages of this function and update to using all gas bounds. -pub fn l1_resource_bounds(max_amount: GasAmount, max_price: GasPrice) -> ValidResourceBounds { - ValidResourceBounds::L1Gas(ResourceBounds { - max_amount: max_amount.0, - max_price_per_unit: max_price.0, - }) +pub fn l1_resource_bounds( + max_amount: GasAmount, + max_price_per_unit: GasPrice, +) -> ValidResourceBounds { + ValidResourceBounds::L1Gas(ResourceBounds { max_amount, max_price_per_unit }) } #[fixture] @@ -364,11 +364,11 @@ pub fn create_all_resource_bounds( l1_data_max_price: GasPrice, ) -> ValidResourceBounds { ValidResourceBounds::AllResources(AllResourceBounds { - l1_gas: ResourceBounds { max_amount: l1_max_amount.0, max_price_per_unit: l1_max_price.0 }, - l2_gas: ResourceBounds { max_amount: l2_max_amount.0, max_price_per_unit: l2_max_price.0 }, + l1_gas: ResourceBounds { max_amount: l1_max_amount, max_price_per_unit: l1_max_price }, + l2_gas: ResourceBounds { max_amount: l2_max_amount, max_price_per_unit: l2_max_price }, l1_data_gas: ResourceBounds { - max_amount: l1_data_max_amount.0, - max_price_per_unit: l1_data_max_price.0, + max_amount: l1_data_max_amount, + max_price_per_unit: l1_data_max_price, }, }) } diff --git a/crates/blockifier/src/transaction/transactions_test.rs b/crates/blockifier/src/transaction/transactions_test.rs index 414b1700fd4..e12e1631795 100644 --- a/crates/blockifier/src/transaction/transactions_test.rs +++ b/crates/blockifier/src/transaction/transactions_test.rs @@ -983,16 +983,16 @@ fn test_insufficient_new_resource_bounds( let default_resource_bounds = AllResourceBounds { l1_gas: ResourceBounds { - max_amount: minimal_gas_vector.l1_gas.0, - max_price_per_unit: actual_strk_l1_gas_price.get().0, + max_amount: minimal_gas_vector.l1_gas, + max_price_per_unit: actual_strk_l1_gas_price.get(), }, l2_gas: ResourceBounds { - max_amount: minimal_gas_vector.l2_gas.0, - max_price_per_unit: actual_strk_l2_gas_price.get().0, + max_amount: minimal_gas_vector.l2_gas, + max_price_per_unit: actual_strk_l2_gas_price.get(), }, l1_data_gas: ResourceBounds { - max_amount: minimal_gas_vector.l1_data_gas.0, - max_price_per_unit: actual_strk_l1_data_gas_price.get().0, + max_amount: minimal_gas_vector.l1_data_gas, + max_price_per_unit: actual_strk_l1_data_gas_price.get(), }, }; @@ -1029,14 +1029,14 @@ fn test_insufficient_new_resource_bounds( (L2Gas, default_resource_bounds.l2_gas), (L1DataGas, default_resource_bounds.l1_data_gas), ] { - if resource_bounds.max_amount == 0 { + if resource_bounds.max_amount == 0_u8.into() { continue; } let mut invalid_resources = default_resource_bounds; match insufficient_resource { - L1Gas => invalid_resources.l1_gas.max_amount -= 1, - L2Gas => invalid_resources.l2_gas.max_amount -= 1, - L1DataGas => invalid_resources.l1_data_gas.max_amount -= 1, + L1Gas => invalid_resources.l1_gas.max_amount.0 -= 1, + L2Gas => invalid_resources.l2_gas.max_amount.0 -= 1, + L1DataGas => invalid_resources.l1_data_gas.max_amount.0 -= 1, } let invalid_v3_tx = account_invoke_tx(InvokeTxArgs { resource_bounds: ValidResourceBounds::AllResources(invalid_resources), @@ -1059,9 +1059,9 @@ fn test_insufficient_new_resource_bounds( for insufficient_resource in [L1Gas, L2Gas, L1DataGas] { let mut invalid_resources = default_resource_bounds; match insufficient_resource { - L1Gas => invalid_resources.l1_gas.max_price_per_unit -= 1, - L2Gas => invalid_resources.l2_gas.max_price_per_unit -= 1, - L1DataGas => invalid_resources.l1_data_gas.max_price_per_unit -= 1, + L1Gas => invalid_resources.l1_gas.max_price_per_unit.0 -= 1, + L2Gas => invalid_resources.l2_gas.max_price_per_unit.0 -= 1, + L1DataGas => invalid_resources.l1_data_gas.max_price_per_unit.0 -= 1, } let invalid_v3_tx = account_invoke_tx(InvokeTxArgs { diff --git a/crates/gateway/src/stateful_transaction_validator_test.rs b/crates/gateway/src/stateful_transaction_validator_test.rs index 1a12cde10ba..4a6b09cf02c 100644 --- a/crates/gateway/src/stateful_transaction_validator_test.rs +++ b/crates/gateway/src/stateful_transaction_validator_test.rs @@ -15,8 +15,10 @@ use mockall::predicate::eq; use num_bigint::BigUint; use pretty_assertions::assert_eq; use rstest::{fixture, rstest}; +use starknet_api::block::GasPrice; use starknet_api::core::Nonce; use starknet_api::executable_transaction::Transaction; +use starknet_api::execution_resources::GasAmount; use starknet_api::test_utils::deploy_account::executable_deploy_account_tx; use starknet_api::test_utils::invoke::executable_invoke_tx; use starknet_api::transaction::Resource; @@ -36,8 +38,8 @@ pub const STATEFUL_VALIDATOR_FEE_ERROR: BlockifierStatefulValidatorError = TransactionPreValidationError::TransactionFeeError( TransactionFeeError::GasBoundsExceedBalance { resource: Resource::L1DataGas, - max_amount: VALID_L1_GAS_MAX_AMOUNT, - max_price: VALID_L1_GAS_MAX_PRICE_PER_UNIT, + max_amount: GasAmount(VALID_L1_GAS_MAX_AMOUNT), + max_price: GasPrice(VALID_L1_GAS_MAX_PRICE_PER_UNIT), balance: BigUint::ZERO, }, ), diff --git a/crates/gateway/src/stateless_transaction_validator.rs b/crates/gateway/src/stateless_transaction_validator.rs index 0a60bf2e06b..2043465da7b 100644 --- a/crates/gateway/src/stateless_transaction_validator.rs +++ b/crates/gateway/src/stateless_transaction_validator.rs @@ -1,3 +1,5 @@ +use starknet_api::block::GasPrice; +use starknet_api::execution_resources::GasAmount; use starknet_api::rpc_transaction::{ RpcDeclareTransaction, RpcDeployAccountTransaction, @@ -179,7 +181,9 @@ fn validate_resource_is_non_zero( resource: Resource, ) -> StatelessTransactionValidatorResult<()> { let resource_bounds = all_resource_bounds.get_bound(resource); - if resource_bounds.max_amount == 0 || resource_bounds.max_price_per_unit == 0 { + if resource_bounds.max_amount == GasAmount(0) + || resource_bounds.max_price_per_unit == GasPrice(0) + { return Err(StatelessTransactionValidatorError::ZeroResourceBounds { resource, resource_bounds, diff --git a/crates/mempool/src/mempool.rs b/crates/mempool/src/mempool.rs index 806caf13901..3fbdda2d127 100644 --- a/crates/mempool/src/mempool.rs +++ b/crates/mempool/src/mempool.rs @@ -1,5 +1,6 @@ use std::collections::HashMap; +use starknet_api::block::GasPrice; use starknet_api::core::{ContractAddress, Nonce}; use starknet_api::executable_transaction::Transaction; use starknet_api::transaction::{Tip, TransactionHash, ValidResourceBounds}; @@ -135,7 +136,7 @@ impl Mempool { } // TODO(Mohammad): Rename this method once consensus API is added. - fn _update_gas_price_threshold(&mut self, threshold: u128) { + fn _update_gas_price_threshold(&mut self, threshold: GasPrice) { self.tx_queue._update_gas_price_threshold(threshold); } @@ -237,7 +238,7 @@ impl TransactionReference { } } - pub fn get_l2_gas_price(&self) -> u128 { + pub fn get_l2_gas_price(&self) -> GasPrice { self.resource_bounds.get_l2_bounds().max_price_per_unit } } diff --git a/crates/mempool/src/mempool_test.rs b/crates/mempool/src/mempool_test.rs index 48d7c21acd5..5bc53a6d63b 100644 --- a/crates/mempool/src/mempool_test.rs +++ b/crates/mempool/src/mempool_test.rs @@ -3,6 +3,7 @@ use std::cmp::Reverse; use mempool_test_utils::starknet_api_test_utils::test_resource_bounds_mapping; use pretty_assertions::assert_eq; use rstest::{fixture, rstest}; +use starknet_api::block::GasPrice; use starknet_api::core::{ContractAddress, PatriciaKey}; use starknet_api::executable_transaction::Transaction; use starknet_api::hash::StarkHash; @@ -280,11 +281,11 @@ fn test_get_txs_while_decreasing_gas_price_threshold() { // Test. // High gas price threshold, no transactions should be returned. - mempool._update_gas_price_threshold(1000000000000); + mempool._update_gas_price_threshold(GasPrice(1000000000000)); get_txs_and_assert_expected(&mut mempool, 1, &[]); // Low gas price threshold, the transaction should be returned. - mempool._update_gas_price_threshold(100); + mempool._update_gas_price_threshold(GasPrice(100)); get_txs_and_assert_expected(&mut mempool, 1, &[tx]); } @@ -302,11 +303,11 @@ fn test_get_txs_while_increasing_gas_price_threshold() { // Test. // Low gas price threshold, the transaction should be returned. - mempool._update_gas_price_threshold(100); + mempool._update_gas_price_threshold(GasPrice(100)); get_txs_and_assert_expected(&mut mempool, 1, &[tx_nonce_0]); // High gas price threshold, no transactions should be returned. - mempool._update_gas_price_threshold(1000000000000); + mempool._update_gas_price_threshold(GasPrice(1000000000000)); get_txs_and_assert_expected(&mut mempool, 1, &[]); } diff --git a/crates/mempool/src/transaction_queue.rs b/crates/mempool/src/transaction_queue.rs index 22f14045cf3..978dfb46a7a 100644 --- a/crates/mempool/src/transaction_queue.rs +++ b/crates/mempool/src/transaction_queue.rs @@ -1,7 +1,9 @@ use std::cmp::Ordering; use std::collections::{BTreeSet, HashMap}; +use starknet_api::block::GasPrice; use starknet_api::core::{ContractAddress, Nonce}; +use starknet_api::execution_resources::GasAmount; use starknet_api::transaction::{ AllResourceBounds, ResourceBounds, @@ -21,7 +23,7 @@ pub mod transaction_queue_test_utils; // used. #[derive(Debug, Default, Eq, PartialEq)] pub struct TransactionQueue { - gas_price_threshold: u128, + gas_price_threshold: GasPrice, // Transactions with gas price above gas price threshold (sorted by tip). priority_queue: BTreeSet, // Transactions with gas price below gas price threshold (sorted by price). @@ -89,7 +91,7 @@ impl TransactionQueue { self.priority_queue.is_empty() } - pub fn _update_gas_price_threshold(&mut self, threshold: u128) { + pub fn _update_gas_price_threshold(&mut self, threshold: GasPrice) { match threshold.cmp(&self.gas_price_threshold) { Ordering::Less => self._promote_txs_to_priority(threshold), Ordering::Greater => self._demote_txs_to_pending(threshold), @@ -99,10 +101,10 @@ impl TransactionQueue { self.gas_price_threshold = threshold; } - fn _promote_txs_to_priority(&mut self, threshold: u128) { + fn _promote_txs_to_priority(&mut self, threshold: GasPrice) { let tmp_split_tx = PendingTransaction(TransactionReference { resource_bounds: ValidResourceBounds::AllResources(AllResourceBounds { - l2_gas: ResourceBounds { max_amount: 0, max_price_per_unit: threshold }, + l2_gas: ResourceBounds { max_amount: GasAmount(0), max_price_per_unit: threshold }, ..Default::default() }), sender_address: ContractAddress::default(), @@ -121,7 +123,7 @@ impl TransactionQueue { self.priority_queue.extend(txs_over_threshold.map(|tx| PriorityTransaction::from(tx.0))); } - fn _demote_txs_to_pending(&mut self, threshold: u128) { + fn _demote_txs_to_pending(&mut self, threshold: GasPrice) { let mut txs_to_remove = Vec::new(); // Remove all transactions from the priority queue that are below the threshold. diff --git a/crates/mempool/src/transaction_queue_test_utils.rs b/crates/mempool/src/transaction_queue_test_utils.rs index 493d8224eeb..37b808f2384 100644 --- a/crates/mempool/src/transaction_queue_test_utils.rs +++ b/crates/mempool/src/transaction_queue_test_utils.rs @@ -42,7 +42,12 @@ impl TransactionQueueContent { } } - TransactionQueue { priority_queue, pending_queue, address_to_tx, gas_price_threshold: 0 } + TransactionQueue { + priority_queue, + pending_queue, + address_to_tx, + gas_price_threshold: 0_u8.into(), + } } } diff --git a/crates/mempool_test_utils/src/starknet_api_test_utils.rs b/crates/mempool_test_utils/src/starknet_api_test_utils.rs index 7eb79c069c4..89174e51024 100644 --- a/crates/mempool_test_utils/src/starknet_api_test_utils.rs +++ b/crates/mempool_test_utils/src/starknet_api_test_utils.rs @@ -10,9 +10,11 @@ use blockifier::test_utils::contracts::FeatureContract; use blockifier::test_utils::{create_trivial_calldata, CairoVersion}; use pretty_assertions::assert_ne; use serde_json::to_string_pretty; +use starknet_api::block::GasPrice; use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce}; use starknet_api::data_availability::DataAvailabilityMode; use starknet_api::executable_transaction::Transaction; +use starknet_api::execution_resources::GasAmount; use starknet_api::rpc_transaction::{ ContractClass, RpcDeclareTransactionV3, @@ -97,7 +99,7 @@ pub fn rpc_tx_for_testing( } pub const NON_EMPTY_RESOURCE_BOUNDS: ResourceBounds = - ResourceBounds { max_amount: 1, max_price_per_unit: 1 }; + ResourceBounds { max_amount: GasAmount(1), max_price_per_unit: GasPrice(1) }; // TODO(Nimrod): Delete this function. pub fn create_resource_bounds_mapping( @@ -119,16 +121,16 @@ pub fn zero_resource_bounds_mapping() -> AllResourceBounds { pub fn test_resource_bounds_mapping() -> AllResourceBounds { create_resource_bounds_mapping( ResourceBounds { - max_amount: VALID_L1_GAS_MAX_AMOUNT, - max_price_per_unit: VALID_L1_GAS_MAX_PRICE_PER_UNIT, + max_amount: GasAmount(VALID_L1_GAS_MAX_AMOUNT), + max_price_per_unit: GasPrice(VALID_L1_GAS_MAX_PRICE_PER_UNIT), }, ResourceBounds { - max_amount: VALID_L2_GAS_MAX_AMOUNT, - max_price_per_unit: VALID_L2_GAS_MAX_PRICE_PER_UNIT, + max_amount: GasAmount(VALID_L2_GAS_MAX_AMOUNT), + max_price_per_unit: GasPrice(VALID_L2_GAS_MAX_PRICE_PER_UNIT), }, ResourceBounds { - max_amount: VALID_L1_DATA_GAS_MAX_AMOUNT, - max_price_per_unit: VALID_L1_DATA_GAS_MAX_PRICE_PER_UNIT, + max_amount: GasAmount(VALID_L1_DATA_GAS_MAX_AMOUNT), + max_price_per_unit: GasPrice(VALID_L1_DATA_GAS_MAX_PRICE_PER_UNIT), }, ) } diff --git a/crates/native_blockifier/src/py_transaction.rs b/crates/native_blockifier/src/py_transaction.rs index e6886685e8f..f4c54aa395b 100644 --- a/crates/native_blockifier/src/py_transaction.rs +++ b/crates/native_blockifier/src/py_transaction.rs @@ -11,6 +11,8 @@ use blockifier::transaction::transaction_execution::Transaction; use blockifier::transaction::transaction_types::TransactionType; use pyo3::exceptions::PyValueError; use pyo3::prelude::*; +use starknet_api::block::GasPrice; +use starknet_api::execution_resources::GasAmount; use starknet_api::transaction::{ DeprecatedResourceBoundsMapping, Resource, @@ -64,8 +66,8 @@ pub struct PyResourceBounds { impl From for starknet_api::transaction::ResourceBounds { fn from(py_resource_bounds: PyResourceBounds) -> Self { Self { - max_amount: py_resource_bounds.max_amount, - max_price_per_unit: py_resource_bounds.max_price_per_unit, + max_amount: GasAmount(py_resource_bounds.max_amount), + max_price_per_unit: GasPrice(py_resource_bounds.max_price_per_unit), } } } diff --git a/crates/papyrus_protobuf/src/converters/consensus_test.rs b/crates/papyrus_protobuf/src/converters/consensus_test.rs index 51810f9e612..5e32edb3c61 100644 --- a/crates/papyrus_protobuf/src/converters/consensus_test.rs +++ b/crates/papyrus_protobuf/src/converters/consensus_test.rs @@ -7,6 +7,7 @@ use papyrus_test_utils::{ use rand::Rng; use starknet_api::block::BlockHash; use starknet_api::core::ContractAddress; +use starknet_api::execution_resources::GasAmount; use starknet_api::transaction::{ DeclareTransaction, DeclareTransactionV3, @@ -136,7 +137,7 @@ fn convert_proposal_to_vec_u8_and_back() { .. })) => { if let ValidResourceBounds::AllResources(ref mut bounds) = resource_bounds { - bounds.l2_gas.max_amount = 1; + bounds.l2_gas.max_amount = GasAmount(1); } } _ => {} diff --git a/crates/papyrus_protobuf/src/converters/rpc_transaction_test.rs b/crates/papyrus_protobuf/src/converters/rpc_transaction_test.rs index 7a309f1d030..7984e4dd5f0 100644 --- a/crates/papyrus_protobuf/src/converters/rpc_transaction_test.rs +++ b/crates/papyrus_protobuf/src/converters/rpc_transaction_test.rs @@ -1,5 +1,7 @@ use lazy_static::lazy_static; use papyrus_test_utils::{get_rng, GetTestInstance}; +use starknet_api::block::GasPrice; +use starknet_api::execution_resources::GasAmount; use starknet_api::rpc_transaction::{ RpcDeclareTransaction, RpcDeclareTransactionV3, @@ -54,8 +56,11 @@ fn assert_transaction_to_vec_u8_and_back(transaction: RpcTransaction) { lazy_static! { static ref RESOURCE_BOUNDS_MAPPING: AllResourceBounds = AllResourceBounds { - l1_gas: ResourceBounds { max_amount: 0x5, max_price_per_unit: 0x6 }, - l2_gas: ResourceBounds { max_amount: 0x6, max_price_per_unit: 0x7 }, - l1_data_gas: ResourceBounds { max_amount: 0x7, max_price_per_unit: 0x8 }, + l1_gas: ResourceBounds { max_amount: GasAmount(0x5), max_price_per_unit: GasPrice(0x6) }, + l2_gas: ResourceBounds { max_amount: GasAmount(0x6), max_price_per_unit: GasPrice(0x7) }, + l1_data_gas: ResourceBounds { + max_amount: GasAmount(0x7), + max_price_per_unit: GasPrice(0x8) + }, }; } diff --git a/crates/papyrus_protobuf/src/converters/transaction.rs b/crates/papyrus_protobuf/src/converters/transaction.rs index 3179088ce6b..81aaf05444b 100644 --- a/crates/papyrus_protobuf/src/converters/transaction.rs +++ b/crates/papyrus_protobuf/src/converters/transaction.rs @@ -4,7 +4,9 @@ mod transaction_test; use std::convert::{TryFrom, TryInto}; use prost::Message; +use starknet_api::block::GasPrice; use starknet_api::core::{ClassHash, CompiledClassHash, EntryPointSelector, Nonce}; +use starknet_api::execution_resources::GasAmount; use starknet_api::transaction::{ AccountDeploymentData, AllResourceBounds, @@ -592,15 +594,18 @@ impl TryFrom for ResourceBounds { value_as_str: format!("{max_price_per_unit_felt:?}"), } })?; - Ok(ResourceBounds { max_amount, max_price_per_unit }) + Ok(ResourceBounds { + max_amount: GasAmount(max_amount), + max_price_per_unit: GasPrice(max_price_per_unit), + }) } } impl From for protobuf::ResourceLimits { fn from(value: ResourceBounds) -> Self { protobuf::ResourceLimits { - max_amount: value.max_amount, - max_price_per_unit: Some(Felt::from(value.max_price_per_unit).into()), + max_amount: value.max_amount.0, + max_price_per_unit: Some(Felt::from(value.max_price_per_unit.0).into()), } } } diff --git a/crates/papyrus_protobuf/src/converters/transaction_test.rs b/crates/papyrus_protobuf/src/converters/transaction_test.rs index d8ac5a49670..7134299385e 100644 --- a/crates/papyrus_protobuf/src/converters/transaction_test.rs +++ b/crates/papyrus_protobuf/src/converters/transaction_test.rs @@ -1,7 +1,8 @@ use lazy_static::lazy_static; use papyrus_test_utils::{get_rng, GetTestInstance}; use rand::random; -use starknet_api::execution_resources::{Builtin, ExecutionResources, GasVector}; +use starknet_api::block::GasPrice; +use starknet_api::execution_resources::{Builtin, ExecutionResources, GasAmount, GasVector}; use starknet_api::transaction::{ AllResourceBounds, DeclareTransaction, @@ -198,8 +199,17 @@ lazy_static! { }; static ref RESOURCE_BOUNDS_MAPPING: ValidResourceBounds = ValidResourceBounds::AllResources(AllResourceBounds { - l1_gas: ResourceBounds { max_amount: 0x5, max_price_per_unit: 0x6 }, - l2_gas: ResourceBounds { max_amount: 0x500, max_price_per_unit: 0x600 }, - l1_data_gas: ResourceBounds { max_amount: 0x30, max_price_per_unit: 0x30 } + l1_gas: ResourceBounds { + max_amount: GasAmount(0x5), + max_price_per_unit: GasPrice(0x6) + }, + l2_gas: ResourceBounds { + max_amount: GasAmount(0x500), + max_price_per_unit: GasPrice(0x600) + }, + l1_data_gas: ResourceBounds { + max_amount: GasAmount(0x30), + max_price_per_unit: GasPrice(0x30) + } }); } diff --git a/crates/papyrus_storage/src/serialization/serializers.rs b/crates/papyrus_storage/src/serialization/serializers.rs index 815e7f7d7e0..7cd25da6be3 100644 --- a/crates/papyrus_storage/src/serialization/serializers.rs +++ b/crates/papyrus_storage/src/serialization/serializers.rs @@ -367,8 +367,8 @@ auto_storage_serde! { L1DataGas = 2, } pub struct ResourceBounds { - pub max_amount: u64, - pub max_price_per_unit: u128, + pub max_amount: GasAmount, + pub max_price_per_unit: GasPrice, } pub struct SequencerContractAddress(pub ContractAddress); pub struct Signature { diff --git a/crates/papyrus_test_utils/src/lib.rs b/crates/papyrus_test_utils/src/lib.rs index a3145d67c90..321a19e4120 100644 --- a/crates/papyrus_test_utils/src/lib.rs +++ b/crates/papyrus_test_utils/src/lib.rs @@ -733,8 +733,8 @@ auto_impl_get_test_instance! { L2Gas = 1, } pub struct ResourceBounds { - pub max_amount: u64, - pub max_price_per_unit: u128, + pub max_amount: GasAmount, + pub max_price_per_unit: GasPrice, } pub struct RpcContractClass { pub sierra_program: Vec, diff --git a/crates/starknet_api/src/block.rs b/crates/starknet_api/src/block.rs index c922cec7500..1c74cdb8590 100644 --- a/crates/starknet_api/src/block.rs +++ b/crates/starknet_api/src/block.rs @@ -7,6 +7,7 @@ use std::fmt::Display; use derive_more::Display; use itertools::Itertools; use serde::{Deserialize, Serialize}; +use starknet_types_core::felt::Felt; use starknet_types_core::hash::{Poseidon, StarkHash as CoreStarkHash}; use crate::core::{ @@ -264,6 +265,12 @@ impl From for PrefixedBytesAsHex<16_usize> { } } +impl From for Felt { + fn from(val: GasPrice) -> Self { + Felt::from(val.0) + } +} + impl GasPrice { pub const fn saturating_mul(self, rhs: GasAmount) -> Fee { #[allow(clippy::as_conversions)] diff --git a/crates/starknet_api/src/rpc_transaction_test.rs b/crates/starknet_api/src/rpc_transaction_test.rs index 92777b53eca..15faf7f2b8a 100644 --- a/crates/starknet_api/src/rpc_transaction_test.rs +++ b/crates/starknet_api/src/rpc_transaction_test.rs @@ -3,7 +3,9 @@ use std::sync::Arc; use rstest::rstest; use starknet_types_core::felt::Felt; +use crate::block::GasPrice; use crate::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce, PatriciaKey}; +use crate::execution_resources::GasAmount; use crate::rpc_transaction::{ ContractClass, DataAvailabilityMode, @@ -29,9 +31,9 @@ use crate::{contract_address, felt, patricia_key}; fn create_resource_bounds_for_testing() -> AllResourceBounds { AllResourceBounds { - l1_gas: ResourceBounds { max_amount: 100, max_price_per_unit: 12 }, - l2_gas: ResourceBounds { max_amount: 58, max_price_per_unit: 31 }, - l1_data_gas: ResourceBounds { max_amount: 66, max_price_per_unit: 25 }, + l1_gas: ResourceBounds { max_amount: GasAmount(100), max_price_per_unit: GasPrice(12) }, + l2_gas: ResourceBounds { max_amount: GasAmount(58), max_price_per_unit: GasPrice(31) }, + l1_data_gas: ResourceBounds { max_amount: GasAmount(66), max_price_per_unit: GasPrice(25) }, } } diff --git a/crates/starknet_api/src/transaction.rs b/crates/starknet_api/src/transaction.rs index b8f424aa5ff..28a5174f5d8 100644 --- a/crates/starknet_api/src/transaction.rs +++ b/crates/starknet_api/src/transaction.rs @@ -8,7 +8,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer}; use starknet_types_core::felt::Felt; use strum_macros::EnumIter; -use crate::block::{BlockHash, BlockNumber, NonzeroGasPrice}; +use crate::block::{BlockHash, BlockNumber, GasPrice, NonzeroGasPrice}; use crate::core::{ ChainId, ClassHash, @@ -736,6 +736,7 @@ pub struct RevertedTransactionExecutionStatus { Serialize, PartialOrd, Ord, + derive_more::Add, derive_more::Deref, )] #[serde(from = "PrefixedBytesAsHex<16_usize>", into = "PrefixedBytesAsHex<16_usize>")] @@ -1028,49 +1029,53 @@ impl Resource { // TODO(Nimrod): Consider renaming this struct. pub struct ResourceBounds { // Specifies the maximum amount of each resource allowed for usage during the execution. - #[serde(serialize_with = "u64_to_hex", deserialize_with = "hex_to_u64")] - pub max_amount: u64, + #[serde(serialize_with = "gas_amount_to_hex", deserialize_with = "hex_to_gas_amount")] + pub max_amount: GasAmount, // Specifies the maximum price the user is willing to pay for each resource unit. - #[serde(serialize_with = "u128_to_hex", deserialize_with = "hex_to_u128")] - pub max_price_per_unit: u128, + #[serde(serialize_with = "gas_price_to_hex", deserialize_with = "hex_to_gas_price")] + pub max_price_per_unit: GasPrice, } impl ResourceBounds { /// Returns true iff both the max amount and the max amount per unit is zero. pub fn is_zero(&self) -> bool { - self.max_amount == 0 && self.max_price_per_unit == 0 + self.max_amount == GasAmount(0) && self.max_price_per_unit == GasPrice(0) } } -fn u64_to_hex(value: &u64, serializer: S) -> Result +fn gas_amount_to_hex(value: &GasAmount, serializer: S) -> Result where S: Serializer, { - serializer.serialize_str(&format!("0x{:x}", value)) + serializer.serialize_str(&format!("0x{:x}", value.0)) } -fn hex_to_u64<'de, D>(deserializer: D) -> Result +fn hex_to_gas_amount<'de, D>(deserializer: D) -> Result where D: Deserializer<'de>, { let s: String = Deserialize::deserialize(deserializer)?; - u64::from_str_radix(s.trim_start_matches("0x"), 16).map_err(serde::de::Error::custom) + Ok(GasAmount( + u64::from_str_radix(s.trim_start_matches("0x"), 16).map_err(serde::de::Error::custom)?, + )) } -fn u128_to_hex(value: &u128, serializer: S) -> Result +fn gas_price_to_hex(value: &GasPrice, serializer: S) -> Result where S: Serializer, { - serializer.serialize_str(&format!("0x{:x}", value)) + serializer.serialize_str(&format!("0x{:x}", value.0)) } -fn hex_to_u128<'de, D>(deserializer: D) -> Result +fn hex_to_gas_price<'de, D>(deserializer: D) -> Result where D: Deserializer<'de>, { let s: String = Deserialize::deserialize(deserializer)?; - u128::from_str_radix(s.trim_start_matches("0x"), 16).map_err(serde::de::Error::custom) + Ok(GasPrice( + u128::from_str_radix(s.trim_start_matches("0x"), 16).map_err(serde::de::Error::custom)?, + )) } #[derive(Debug, PartialEq)] @@ -1106,21 +1111,20 @@ impl ValidResourceBounds { } pub fn max_possible_fee(&self) -> Fee { - Fee(match self { + match self { ValidResourceBounds::L1Gas(l1_bounds) => { - let max_amount: u128 = l1_bounds.max_amount.into(); - max_amount * l1_bounds.max_price_per_unit + l1_bounds.max_amount.saturating_mul(l1_bounds.max_price_per_unit) } ValidResourceBounds::AllResources(AllResourceBounds { l1_gas, l2_gas, l1_data_gas, }) => { - u128::from(l1_gas.max_amount) * l1_gas.max_price_per_unit - + u128::from(l2_gas.max_amount) * l2_gas.max_price_per_unit - + u128::from(l1_data_gas.max_amount) * l1_data_gas.max_price_per_unit + l1_gas.max_amount.saturating_mul(l1_gas.max_price_per_unit) + + l2_gas.max_amount.saturating_mul(l2_gas.max_price_per_unit) + + l1_data_gas.max_amount.saturating_mul(l1_data_gas.max_price_per_unit) } - }) + } } pub fn get_gas_vector_computation_mode(&self) -> GasVectorComputationMode { @@ -1133,7 +1137,7 @@ impl ValidResourceBounds { // TODO(Nimrod): Default testing bounds should probably be AllResourceBounds variant. #[cfg(any(feature = "testing", test))] pub fn create_for_testing() -> Self { - Self::L1Gas(ResourceBounds { max_amount: 0, max_price_per_unit: 1 }) + Self::L1Gas(ResourceBounds { max_amount: GasAmount(0), max_price_per_unit: GasPrice(1) }) } } diff --git a/crates/starknet_api/src/transaction_hash.rs b/crates/starknet_api/src/transaction_hash.rs index 9178f0e9a06..b6b0d98c6f4 100644 --- a/crates/starknet_api/src/transaction_hash.rs +++ b/crates/starknet_api/src/transaction_hash.rs @@ -200,8 +200,8 @@ fn get_concat_resource( resource_bounds: &ResourceBounds, resource_name: &ResourceName, ) -> Result { - let max_amount = resource_bounds.max_amount.to_be_bytes(); - let max_price = resource_bounds.max_price_per_unit.to_be_bytes(); + let max_amount = resource_bounds.max_amount.0.to_be_bytes(); + let max_price = resource_bounds.max_price_per_unit.0.to_be_bytes(); let concat_bytes = [[0_u8].as_slice(), resource_name.as_slice(), max_amount.as_slice(), max_price.as_slice()] .concat(); From 2250d74eaf3e02a467af954097f9b70f04d25606 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 15:55:31 +0300 Subject: [PATCH 36/57] feat(blockifier): event fields converted from u128 to u64 (#1250) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1250) --- crates/blockifier/src/execution/call_info.rs | 10 +++---- crates/blockifier/src/fee/resources.rs | 29 ++++---------------- crates/blockifier/src/test_utils.rs | 6 ++-- crates/blockifier/src/utils.rs | 6 ---- 4 files changed, 14 insertions(+), 37 deletions(-) diff --git a/crates/blockifier/src/execution/call_info.rs b/crates/blockifier/src/execution/call_info.rs index 69fc1602112..62a91a8c563 100644 --- a/crates/blockifier/src/execution/call_info.rs +++ b/crates/blockifier/src/execution/call_info.rs @@ -12,7 +12,7 @@ use starknet_types_core::felt::Felt; use crate::execution::contract_class::TrackedResource; use crate::execution::entry_point::CallEntryPoint; use crate::state::cached_state::StorageEntry; -use crate::utils::u128_from_usize; +use crate::utils::u64_from_usize; #[cfg_attr(feature = "transaction_serde", derive(serde::Deserialize))] #[derive(Clone, Debug, Default, Eq, PartialEq, Serialize)] @@ -65,8 +65,8 @@ pub struct CallExecution { #[derive(Clone, Debug, Default, derive_more::AddAssign, PartialEq)] pub struct EventSummary { pub n_events: usize, - pub total_event_keys: u128, - pub total_event_data_size: u128, + pub total_event_keys: u64, + pub total_event_data_size: u64, } #[derive(Clone, Debug, Default, PartialEq)] @@ -150,8 +150,8 @@ impl CallInfo { // TODO(barak: 18/03/2024): Once we start charging per byte // change to num_bytes_keys // and num_bytes_data. - event_summary.total_event_data_size += u128_from_usize(event.data.0.len()); - event_summary.total_event_keys += u128_from_usize(event.keys.len()); + event_summary.total_event_data_size += u64_from_usize(event.data.0.len()); + event_summary.total_event_keys += u64_from_usize(event.keys.len()); } } diff --git a/crates/blockifier/src/fee/resources.rs b/crates/blockifier/src/fee/resources.rs index 9242572fd30..2cb3cb1290c 100644 --- a/crates/blockifier/src/fee/resources.rs +++ b/crates/blockifier/src/fee/resources.rs @@ -16,11 +16,7 @@ use crate::fee::gas_usage::{ use crate::state::cached_state::{StateChanges, StateChangesCount}; use crate::transaction::errors::TransactionFeeError; use crate::utils::u64_from_usize; -use crate::versioned_constants::{ - resource_cost_to_u128_ratio, - ArchivalDataGasCosts, - VersionedConstants, -}; +use crate::versioned_constants::{ArchivalDataGasCosts, VersionedConstants}; pub type TransactionFeeResult = Result; @@ -215,24 +211,11 @@ impl ArchivalDataResources { /// Returns the cost of the transaction's emmited events in L1/L2 gas units, depending on the /// mode. fn get_events_gas_cost(&self, archival_gas_costs: &ArchivalDataGasCosts) -> GasAmount { - u64::try_from( - (resource_cost_to_u128_ratio(archival_gas_costs.gas_per_data_felt) - * (resource_cost_to_u128_ratio(archival_gas_costs.event_key_factor) - * self.event_summary.total_event_keys - + self.event_summary.total_event_data_size)) - .to_integer(), - ) - .unwrap_or_else(|_| { - panic!( - "Events gas cost overflowed: {} event keys (factor: {}), data length {} (at {} \ - gas per felt).", - self.event_summary.total_event_keys, - archival_gas_costs.event_key_factor, - self.event_summary.total_event_data_size, - archival_gas_costs.gas_per_data_felt - ) - }) - .into() + (archival_gas_costs.gas_per_data_felt + * (archival_gas_costs.event_key_factor * self.event_summary.total_event_keys + + self.event_summary.total_event_data_size)) + .to_integer() + .into() } } diff --git a/crates/blockifier/src/test_utils.rs b/crates/blockifier/src/test_utils.rs index 204c37c450a..388d54dc71d 100644 --- a/crates/blockifier/src/test_utils.rs +++ b/crates/blockifier/src/test_utils.rs @@ -36,7 +36,7 @@ use crate::execution::syscalls::SyscallSelector; use crate::fee::resources::{StarknetResources, StateResources}; use crate::test_utils::contracts::FeatureContract; use crate::transaction::transaction_types::TransactionType; -use crate::utils::{const_max, u128_from_usize}; +use crate::utils::{const_max, u64_from_usize}; use crate::versioned_constants::VersionedConstants; // TODO(Dori, 1/2/2024): Remove these constants once all tests use the `contracts` and // `initial_test_state` modules for testing. @@ -334,7 +334,7 @@ pub fn calldata_for_deploy_test( vec![ class_hash.0, ContractAddressSalt::default().0, - felt!(u128_from_usize(constructor_calldata.len())), + felt!(u64_from_usize(constructor_calldata.len())), ], constructor_calldata.into(), vec![felt!(if valid_deploy_from_zero { 0_u8 } else { 2_u8 })], @@ -365,7 +365,7 @@ pub fn create_calldata( vec![ *contract_address.0.key(), // Contract address. selector_from_name(entry_point_name).0, // EP selector name. - felt!(u128_from_usize(entry_point_args.len())), + felt!(u64_from_usize(entry_point_args.len())), ], entry_point_args.into(), ] diff --git a/crates/blockifier/src/utils.rs b/crates/blockifier/src/utils.rs index ef9c0a6c4d8..b8b067f0d6a 100644 --- a/crates/blockifier/src/utils.rs +++ b/crates/blockifier/src/utils.rs @@ -54,12 +54,6 @@ pub fn usize_from_u64(val: u64) -> Result { val.try_into().map_err(|_| NumericConversionError::U64ToUsizeError(val)) } -/// Conversion from usize to u128. May fail on architectures with over 128 bits -/// of address space. -pub fn u128_from_usize(val: usize) -> u128 { - val.try_into().expect("Conversion from usize to u128 should not fail.") -} - /// Conversion from usize to u64. May fail on architectures with over 64 bits /// of address space. pub fn u64_from_usize(val: usize) -> u64 { From fb8b8905feaad3e98e1e75684e7178d8aa0ea160 Mon Sep 17 00:00:00 2001 From: eitanm-starkware Date: Tue, 8 Oct 2024 18:56:09 +0300 Subject: [PATCH 37/57] chore(network): provide mock testing channels for prop and reporting --- crates/papyrus_network/src/network_manager/test_utils.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/crates/papyrus_network/src/network_manager/test_utils.rs b/crates/papyrus_network/src/network_manager/test_utils.rs index bcc74fb9e97..a4710c6ad74 100644 --- a/crates/papyrus_network/src/network_manager/test_utils.rs +++ b/crates/papyrus_network/src/network_manager/test_utils.rs @@ -95,7 +95,7 @@ where |(x, report_sender)| (T::try_from(x), report_sender); let broadcasted_messages_receiver = broadcasted_messages_receiver.map(broadcasted_messages_fn); - let (reported_messages_sender, _mock_reported_messages_receiver) = + let (reported_messages_sender, mock_reported_messages_receiver) = futures::channel::mpsc::channel(CHANNEL_BUFFER_SIZE); let reported_messages_fn: fn(BroadcastedMessageManager) -> Ready> = |broadcasted_message_manager| { @@ -103,7 +103,7 @@ where }; let reported_messages_sender = reported_messages_sender.with(reported_messages_fn); - let (continue_propagation_sender, _mock_continue_propagation_receiver) = + let (continue_propagation_sender, mock_continue_propagation_receiver) = futures::channel::mpsc::channel(CHANNEL_BUFFER_SIZE); let subscriber_channels = BroadcastTopicChannels { @@ -132,6 +132,8 @@ where let mock_network = BroadcastNetworkMock { broadcasted_messages_sender: mock_broadcasted_messages_sender, messages_to_broadcast_receiver: mock_messages_to_broadcast_receiver, + reported_messages_receiver: mock_reported_messages_receiver, + continue_propagation_receiver: mock_continue_propagation_receiver, }; Ok(TestSubscriberChannels { subscriber_channels, mock_network }) @@ -195,6 +197,8 @@ pub type MockMessagesToBroadcastReceiver = Map, fn(Bytes) -> pub struct BroadcastNetworkMock> { pub broadcasted_messages_sender: MockBroadcastedMessagesSender, pub messages_to_broadcast_receiver: MockMessagesToBroadcastReceiver, + pub reported_messages_receiver: Receiver, + pub continue_propagation_receiver: Receiver, } pub struct TestSubscriberChannels> { From 2833802f6530fae517dc65cbb88553e3bfc81758 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 16:01:13 +0300 Subject: [PATCH 38/57] feat(blockifier): make ErrorStack fields public (#1269) Signed-off-by: Dori Medini --- .../blockifier/src/execution/stack_trace.rs | 25 +++++++++++-------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/crates/blockifier/src/execution/stack_trace.rs b/crates/blockifier/src/execution/stack_trace.rs index 06414576ab0..dedf766f023 100644 --- a/crates/blockifier/src/execution/stack_trace.rs +++ b/crates/blockifier/src/execution/stack_trace.rs @@ -17,7 +17,8 @@ pub mod test; pub const TRACE_LENGTH_CAP: usize = 15000; pub const TRACE_EXTRA_CHARS_SLACK: usize = 100; -enum PreambleType { +#[cfg_attr(feature = "transaction_serde", derive(serde::Serialize, serde::Deserialize))] +pub enum PreambleType { CallContract, LibraryCall, Constructor, @@ -33,12 +34,13 @@ impl PreambleType { } } +#[cfg_attr(feature = "transaction_serde", derive(serde::Serialize, serde::Deserialize))] pub struct EntryPointErrorFrame { - depth: usize, - preamble_type: PreambleType, - storage_address: ContractAddress, - class_hash: ClassHash, - selector: Option, + pub depth: usize, + pub preamble_type: PreambleType, + pub storage_address: ContractAddress, + pub class_hash: ClassHash, + pub selector: Option, } impl EntryPointErrorFrame { @@ -64,10 +66,11 @@ impl From<&EntryPointErrorFrame> for String { } } +#[cfg_attr(feature = "transaction_serde", derive(serde::Serialize, serde::Deserialize))] pub struct VmExceptionFrame { - pc: Relocatable, - error_attr_value: Option, - traceback: Option, + pub pc: Relocatable, + pub error_attr_value: Option, + pub traceback: Option, } impl From<&VmExceptionFrame> for String { @@ -86,6 +89,7 @@ impl From<&VmExceptionFrame> for String { } } +#[cfg_attr(feature = "transaction_serde", derive(serde::Serialize, serde::Deserialize))] pub enum Frame { EntryPoint(EntryPointErrorFrame), Vm(VmExceptionFrame), @@ -120,9 +124,10 @@ impl From for Frame { } } +#[cfg_attr(feature = "transaction_serde", derive(serde::Serialize, serde::Deserialize))] #[derive(Default)] pub struct ErrorStack { - stack: Vec, + pub stack: Vec, } impl From for String { From bc03b4b51ea821ba3046a03aa9c20ec6ee2fe9f0 Mon Sep 17 00:00:00 2001 From: aner-starkware <147302140+aner-starkware@users.noreply.github.com> Date: Wed, 9 Oct 2024 16:09:54 +0300 Subject: [PATCH 39/57] chore(blockifier_reexecution): add blockifier_reexecution to commitlint (#1276) --- Cargo.lock | 2 +- Cargo.toml | 2 +- commitlint.config.js | 1 + .../Cargo.toml | 2 +- .../resources/block_700000/tx_hashes_block_700000.json | 0 .../resources/raw_rpc_json_objects/block_header.json | 0 .../raw_rpc_json_objects/deprecated_contract_class.json | 0 .../resources/raw_rpc_json_objects/transactions.json | 0 .../src/lib.rs | 0 .../src/state_reader.rs | 0 .../src/state_reader/compile.rs | 0 .../src/state_reader/raw_rpc_json_test.rs | 0 .../src/state_reader/rpc_https_test.rs | 0 .../src/state_reader/test_state_reader.rs | 0 .../src/state_reader/utils.rs | 0 15 files changed, 4 insertions(+), 3 deletions(-) rename crates/{blockifier_regression_test => blockifier_reexecution}/Cargo.toml (95%) rename crates/{blockifier_regression_test => blockifier_reexecution}/resources/block_700000/tx_hashes_block_700000.json (100%) rename crates/{blockifier_regression_test => blockifier_reexecution}/resources/raw_rpc_json_objects/block_header.json (100%) rename crates/{blockifier_regression_test => blockifier_reexecution}/resources/raw_rpc_json_objects/deprecated_contract_class.json (100%) rename crates/{blockifier_regression_test => blockifier_reexecution}/resources/raw_rpc_json_objects/transactions.json (100%) rename crates/{blockifier_regression_test => blockifier_reexecution}/src/lib.rs (100%) rename crates/{blockifier_regression_test => blockifier_reexecution}/src/state_reader.rs (100%) rename crates/{blockifier_regression_test => blockifier_reexecution}/src/state_reader/compile.rs (100%) rename crates/{blockifier_regression_test => blockifier_reexecution}/src/state_reader/raw_rpc_json_test.rs (100%) rename crates/{blockifier_regression_test => blockifier_reexecution}/src/state_reader/rpc_https_test.rs (100%) rename crates/{blockifier_regression_test => blockifier_reexecution}/src/state_reader/test_state_reader.rs (100%) rename crates/{blockifier_regression_test => blockifier_reexecution}/src/state_reader/utils.rs (100%) diff --git a/Cargo.lock b/Cargo.lock index 8e598929505..a8a82bd6b54 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1528,7 +1528,7 @@ dependencies = [ ] [[package]] -name = "blockifier_regression_test" +name = "blockifier_reexecution" version = "0.0.0" dependencies = [ "assert_matches", diff --git a/Cargo.toml b/Cargo.toml index 807131858ca..72abf0ec3fb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,7 +7,7 @@ members = [ "crates/batcher", "crates/batcher_types", "crates/blockifier", - "crates/blockifier_regression_test", + "crates/blockifier_reexecution", "crates/committer_cli", "crates/consensus_manager", "crates/consensus_manager_types", diff --git a/commitlint.config.js b/commitlint.config.js index a57cebcf7ec..6ea218299e9 100644 --- a/commitlint.config.js +++ b/commitlint.config.js @@ -23,6 +23,7 @@ const Configuration = { 'batcher', 'block_hash', 'blockifier', + 'blockifier_reexecution', 'ci', 'committer', 'common', diff --git a/crates/blockifier_regression_test/Cargo.toml b/crates/blockifier_reexecution/Cargo.toml similarity index 95% rename from crates/blockifier_regression_test/Cargo.toml rename to crates/blockifier_reexecution/Cargo.toml index 92a5bf3b65f..a6201dece0f 100644 --- a/crates/blockifier_regression_test/Cargo.toml +++ b/crates/blockifier_reexecution/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "blockifier_regression_test" +name = "blockifier_reexecution" version.workspace = true edition.workspace = true repository.workspace = true diff --git a/crates/blockifier_regression_test/resources/block_700000/tx_hashes_block_700000.json b/crates/blockifier_reexecution/resources/block_700000/tx_hashes_block_700000.json similarity index 100% rename from crates/blockifier_regression_test/resources/block_700000/tx_hashes_block_700000.json rename to crates/blockifier_reexecution/resources/block_700000/tx_hashes_block_700000.json diff --git a/crates/blockifier_regression_test/resources/raw_rpc_json_objects/block_header.json b/crates/blockifier_reexecution/resources/raw_rpc_json_objects/block_header.json similarity index 100% rename from crates/blockifier_regression_test/resources/raw_rpc_json_objects/block_header.json rename to crates/blockifier_reexecution/resources/raw_rpc_json_objects/block_header.json diff --git a/crates/blockifier_regression_test/resources/raw_rpc_json_objects/deprecated_contract_class.json b/crates/blockifier_reexecution/resources/raw_rpc_json_objects/deprecated_contract_class.json similarity index 100% rename from crates/blockifier_regression_test/resources/raw_rpc_json_objects/deprecated_contract_class.json rename to crates/blockifier_reexecution/resources/raw_rpc_json_objects/deprecated_contract_class.json diff --git a/crates/blockifier_regression_test/resources/raw_rpc_json_objects/transactions.json b/crates/blockifier_reexecution/resources/raw_rpc_json_objects/transactions.json similarity index 100% rename from crates/blockifier_regression_test/resources/raw_rpc_json_objects/transactions.json rename to crates/blockifier_reexecution/resources/raw_rpc_json_objects/transactions.json diff --git a/crates/blockifier_regression_test/src/lib.rs b/crates/blockifier_reexecution/src/lib.rs similarity index 100% rename from crates/blockifier_regression_test/src/lib.rs rename to crates/blockifier_reexecution/src/lib.rs diff --git a/crates/blockifier_regression_test/src/state_reader.rs b/crates/blockifier_reexecution/src/state_reader.rs similarity index 100% rename from crates/blockifier_regression_test/src/state_reader.rs rename to crates/blockifier_reexecution/src/state_reader.rs diff --git a/crates/blockifier_regression_test/src/state_reader/compile.rs b/crates/blockifier_reexecution/src/state_reader/compile.rs similarity index 100% rename from crates/blockifier_regression_test/src/state_reader/compile.rs rename to crates/blockifier_reexecution/src/state_reader/compile.rs diff --git a/crates/blockifier_regression_test/src/state_reader/raw_rpc_json_test.rs b/crates/blockifier_reexecution/src/state_reader/raw_rpc_json_test.rs similarity index 100% rename from crates/blockifier_regression_test/src/state_reader/raw_rpc_json_test.rs rename to crates/blockifier_reexecution/src/state_reader/raw_rpc_json_test.rs diff --git a/crates/blockifier_regression_test/src/state_reader/rpc_https_test.rs b/crates/blockifier_reexecution/src/state_reader/rpc_https_test.rs similarity index 100% rename from crates/blockifier_regression_test/src/state_reader/rpc_https_test.rs rename to crates/blockifier_reexecution/src/state_reader/rpc_https_test.rs diff --git a/crates/blockifier_regression_test/src/state_reader/test_state_reader.rs b/crates/blockifier_reexecution/src/state_reader/test_state_reader.rs similarity index 100% rename from crates/blockifier_regression_test/src/state_reader/test_state_reader.rs rename to crates/blockifier_reexecution/src/state_reader/test_state_reader.rs diff --git a/crates/blockifier_regression_test/src/state_reader/utils.rs b/crates/blockifier_reexecution/src/state_reader/utils.rs similarity index 100% rename from crates/blockifier_regression_test/src/state_reader/utils.rs rename to crates/blockifier_reexecution/src/state_reader/utils.rs From ce5629996f08692ef07b47f65ad8953d4a74058d Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 16:13:28 +0300 Subject: [PATCH 40/57] feat(blockifier): safe addition of fee amounts in business logic (#1255) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1255) --- crates/blockifier/src/fee/fee_utils.rs | 21 +-------------------- crates/starknet_api/src/transaction.rs | 19 ++++++++++++------- 2 files changed, 13 insertions(+), 27 deletions(-) diff --git a/crates/blockifier/src/fee/fee_utils.rs b/crates/blockifier/src/fee/fee_utils.rs index 5cc9dda5205..426447bca91 100644 --- a/crates/blockifier/src/fee/fee_utils.rs +++ b/crates/blockifier/src/fee/fee_utils.rs @@ -109,26 +109,7 @@ pub fn verify_can_pay_committed_bounds( ) -> TransactionFeeResult<()> { let tx_info = &tx_context.tx_info; let committed_fee = match tx_info { - TransactionInfo::Current(context) => { - match &context.resource_bounds { - L1Gas(l1_gas) => - // Sender will not be charged by `max_price_per_unit`, but this check should not - // depend on the current gas price. - { - l1_gas.max_amount.saturating_mul(l1_gas.max_price_per_unit) - } - // TODO!(Aner): add tests - AllResources(AllResourceBounds { l1_gas, l2_gas, l1_data_gas }) => { - // Committed fee is sum of products (resource_max_amount * resource_max_price) - // of the different resources. - // The Sender will not be charged by`max_price_per_unit`, but this check should - // not depend on the current gas price - l1_gas.max_amount.saturating_mul(l1_gas.max_price_per_unit) - + l1_data_gas.max_amount.saturating_mul(l1_data_gas.max_price_per_unit) - + l2_gas.max_amount.saturating_mul(l2_gas.max_price_per_unit) - } - } - } + TransactionInfo::Current(context) => context.resource_bounds.max_possible_fee(), TransactionInfo::Deprecated(context) => context.max_fee, }; let (balance_low, balance_high, can_pay) = diff --git a/crates/starknet_api/src/transaction.rs b/crates/starknet_api/src/transaction.rs index 28a5174f5d8..edb343cd582 100644 --- a/crates/starknet_api/src/transaction.rs +++ b/crates/starknet_api/src/transaction.rs @@ -723,6 +723,7 @@ pub struct RevertedTransactionExecutionStatus { } /// A fee. +#[cfg_attr(any(test, feature = "testing"), derive(derive_more::Add, derive_more::Deref))] #[derive( Debug, Copy, @@ -736,8 +737,6 @@ pub struct RevertedTransactionExecutionStatus { Serialize, PartialOrd, Ord, - derive_more::Add, - derive_more::Deref, )] #[serde(from = "PrefixedBytesAsHex<16_usize>", into = "PrefixedBytesAsHex<16_usize>")] pub struct Fee(pub u128); @@ -747,6 +746,10 @@ impl Fee { self.0.checked_add(rhs.0).map(Fee) } + pub fn saturating_add(self, rhs: Self) -> Self { + Self(self.0.saturating_add(rhs.0)) + } + pub fn checked_div_ceil(self, rhs: NonzeroGasPrice) -> Option { match self.checked_div(rhs) { Some(value) => Some(if value.nonzero_saturating_mul(rhs) < self { @@ -1119,11 +1122,13 @@ impl ValidResourceBounds { l1_gas, l2_gas, l1_data_gas, - }) => { - l1_gas.max_amount.saturating_mul(l1_gas.max_price_per_unit) - + l2_gas.max_amount.saturating_mul(l2_gas.max_price_per_unit) - + l1_data_gas.max_amount.saturating_mul(l1_data_gas.max_price_per_unit) - } + }) => l1_gas + .max_amount + .saturating_mul(l1_gas.max_price_per_unit) + .saturating_add(l2_gas.max_amount.saturating_mul(l2_gas.max_price_per_unit)) + .saturating_add( + l1_data_gas.max_amount.saturating_mul(l1_data_gas.max_price_per_unit), + ), } } From ee4531b2ee26c6e9197face55e2b32f2a91fa41b Mon Sep 17 00:00:00 2001 From: yoavGrs <97383386+yoavGrs@users.noreply.github.com> Date: Wed, 9 Oct 2024 16:18:55 +0300 Subject: [PATCH 41/57] test(blockifier): add case for cairo steps contract (#1270) test(blockifier): add case for cairo steps contract --- .../workflows/blockifier_compiled_cairo.yml | 5 + .../cairo1/cairo_steps_test_contract.cairo | 634 + .../cairo_steps_test_contract.casm.json | 36214 ++++++++++++++++ crates/blockifier/src/test_utils/contracts.rs | 50 +- 4 files changed, 36884 insertions(+), 19 deletions(-) create mode 100644 crates/blockifier/feature_contracts/cairo1/cairo_steps_test_contract.cairo create mode 100644 crates/blockifier/feature_contracts/cairo1/compiled/cairo_steps_test_contract.casm.json diff --git a/.github/workflows/blockifier_compiled_cairo.yml b/.github/workflows/blockifier_compiled_cairo.yml index 5703f3e3e10..c2ffebae76b 100644 --- a/.github/workflows/blockifier_compiled_cairo.yml +++ b/.github/workflows/blockifier_compiled_cairo.yml @@ -56,6 +56,11 @@ jobs: with: toolchain: nightly-2023-07-05 + - name: install toolchain for cairo steps test contract compilation (old compiler tag) + uses: actions-rs/toolchain@master + with: + toolchain: nightly-2024-04-29 + - name: Verify cairo contract recompilation (both cairo versions). run: cd sequencer && diff --git a/crates/blockifier/feature_contracts/cairo1/cairo_steps_test_contract.cairo b/crates/blockifier/feature_contracts/cairo1/cairo_steps_test_contract.cairo new file mode 100644 index 00000000000..d87a76efda4 --- /dev/null +++ b/crates/blockifier/feature_contracts/cairo1/cairo_steps_test_contract.cairo @@ -0,0 +1,634 @@ +#[starknet::contract] +mod TestContract { + use box::BoxTrait; + use core::sha256::{compute_sha256_u32_array, sha256_state_handle_init, SHA256_INITIAL_STATE}; + use dict::Felt252DictTrait; + use ec::EcPointTrait; + use starknet::ClassHash; + use starknet::ContractAddress; + use starknet::get_execution_info; + use starknet::StorageAddress; + use array::ArrayTrait; + use clone::Clone; + use core::bytes_31::POW_2_128; + use core::integer::bitwise; + use traits::Into; + use traits::TryInto; + use starknet::{ + class_hash_try_from_felt252, contract_address_try_from_felt252, + eth_address::U256IntoEthAddress, EthAddress, secp256_trait::{Signature, is_valid_signature}, + secp256r1::{Secp256r1Point, Secp256r1Impl}, eth_signature::verify_eth_signature, + info::{BlockInfo, SyscallResultTrait}, info::v2::{ExecutionInfo, TxInfo, ResourceBounds,}, + syscalls + }; + use core::circuit::{ + CircuitElement, CircuitInput, circuit_add, circuit_sub, circuit_mul, circuit_inverse, + EvalCircuitResult, EvalCircuitTrait, u384, CircuitOutputsTrait, + CircuitModulus, CircuitInputs, AddInputResultTrait + }; + + #[storage] + struct Storage { + my_storage_var: felt252, + two_counters: starknet::storage::Map, + ec_point: (felt252, felt252), + } + + #[constructor] + fn constructor(ref self: ContractState, arg1: felt252, arg2: felt252) -> felt252 { + self.my_storage_var.write(arg1 + arg2); + arg1 + } + + #[external(v0)] + fn test_storage_read_write( + self: @ContractState, address: StorageAddress, value: felt252 + ) -> felt252 { + let address_domain = 0; + syscalls::storage_write_syscall(address_domain, address, value).unwrap_syscall(); + syscalls::storage_read_syscall(address_domain, address).unwrap_syscall() + } + + #[external(v0)] + fn test_count_actual_storage_changes(self: @ContractState) { + let storage_address = 15.try_into().unwrap(); + let address_domain = 0; + syscalls::storage_write_syscall(address_domain, storage_address, 0).unwrap_syscall(); + syscalls::storage_write_syscall(address_domain, storage_address, 1).unwrap_syscall(); + } + + #[external(v0)] + #[raw_output] + fn test_call_contract( + self: @ContractState, + contract_address: ContractAddress, + entry_point_selector: felt252, + calldata: Array:: + ) -> Span:: { + syscalls::call_contract_syscall(contract_address, entry_point_selector, calldata.span()) + .unwrap_syscall() + .snapshot + .span() + } + + #[external(v0)] + fn test_call_two_contracts( + self: @ContractState, + contract_address_0: ContractAddress, + entry_point_selector_0: felt252, + calldata_0: Array::, + contract_address_1: ContractAddress, + entry_point_selector_1: felt252, + calldata_1: Array::, + ) -> Span:: { + let res_0 = syscalls::call_contract_syscall( + contract_address_0, + entry_point_selector_0, + calldata_0.span(), + ) + .unwrap_syscall(); + let res_1 = syscalls::call_contract_syscall( + contract_address_1, + entry_point_selector_1, + calldata_1.span(), + ) + .unwrap_syscall(); + let mut res: Array:: = Default::default(); + res.append_span(res_0.snapshot.span()); + res.append_span(res_1.snapshot.span()); + res.span() + } + + #[external(v0)] + fn test_revert_helper(ref self: ContractState, class_hash: ClassHash) { + let dummy_span = array![0].span(); + syscalls::emit_event_syscall(dummy_span, dummy_span).unwrap_syscall(); + syscalls::replace_class_syscall(class_hash).unwrap_syscall(); + syscalls::send_message_to_l1_syscall(17.try_into().unwrap(), dummy_span).unwrap_syscall(); + self.my_storage_var.write(17); + panic!("test_revert_helper"); + } + + #[external(v0)] + fn test_emit_events( + self: @ContractState, events_number: u64, keys: Array::, data: Array:: + ) { + let mut c = 0_u64; + loop { + if c == events_number { + break; + } + syscalls::emit_event_syscall(keys.span(), data.span()).unwrap_syscall(); + c += 1; + }; + } + + #[external(v0)] + fn test_get_block_hash(self: @ContractState, block_number: u64) -> felt252 { + syscalls::get_block_hash_syscall(block_number).unwrap_syscall() + } + + #[external(v0)] + fn test_get_execution_info( + self: @ContractState, + expected_block_info: BlockInfo, + expected_tx_info: TxInfo, + // Expected call info. + expected_caller_address: felt252, + expected_contract_address: felt252, + expected_entry_point_selector: felt252, + ) { + let execution_info = starknet::get_execution_info().unbox(); + let block_info = execution_info.block_info.unbox(); + assert(block_info == expected_block_info, 'BLOCK_INFO_MISMATCH'); + + let tx_info = execution_info.tx_info.unbox(); + assert(tx_info == expected_tx_info, 'TX_INFO_MISMATCH'); + + assert(execution_info.caller_address.into() == expected_caller_address, 'CALLER_MISMATCH'); + assert( + execution_info.contract_address.into() == expected_contract_address, 'CONTRACT_MISMATCH' + ); + assert( + execution_info.entry_point_selector == expected_entry_point_selector, + 'SELECTOR_MISMATCH' + ); + } + + #[external(v0)] + #[raw_output] + fn test_library_call( + self: @ContractState, + class_hash: ClassHash, + function_selector: felt252, + calldata: Array + ) -> Span:: { + starknet::library_call_syscall(class_hash, function_selector, calldata.span()) + .unwrap_syscall() + .snapshot + .span() + } + + #[external(v0)] + #[raw_output] + fn test_nested_library_call( + self: @ContractState, + class_hash: ClassHash, + lib_selector: felt252, + nested_selector: felt252, + a: felt252, + b: felt252 + ) -> Span:: { + let mut nested_library_calldata: Array:: = Default::default(); + nested_library_calldata.append(class_hash.into()); + nested_library_calldata.append(nested_selector); + nested_library_calldata.append(2); + nested_library_calldata.append(a + 1); + nested_library_calldata.append(b + 1); + let _res = starknet::library_call_syscall( + class_hash, lib_selector, nested_library_calldata.span(), + ) + .unwrap_syscall(); + + let mut calldata: Array:: = Default::default(); + calldata.append(a); + calldata.append(b); + starknet::library_call_syscall(class_hash, nested_selector, calldata.span()) + .unwrap_syscall() + } + + #[external(v0)] + fn test_replace_class(self: @ContractState, class_hash: ClassHash) { + syscalls::replace_class_syscall(class_hash).unwrap_syscall(); + } + + #[external(v0)] + fn test_send_message_to_l1( + self: @ContractState, to_address: felt252, payload: Array:: + ) { + starknet::send_message_to_l1_syscall(to_address, payload.span()).unwrap_syscall(); + } + + /// An external method that requires the `segment_arena` builtin. + #[external(v0)] + fn segment_arena_builtin(self: @ContractState) { + let x = felt252_dict_new::(); + x.squash(); + } + + #[l1_handler] + fn l1_handle(self: @ContractState, from_address: felt252, arg: felt252) -> felt252 { + arg + } + + #[l1_handler] + fn l1_handler_set_value( + self: @ContractState, from_address: felt252, key: StorageAddress, value: felt252 + ) -> felt252 { + let address_domain = 0; + syscalls::storage_write_syscall(address_domain, key, value).unwrap_syscall(); + value + } + + #[external(v0)] + fn test_deploy( + self: @ContractState, + class_hash: ClassHash, + contract_address_salt: felt252, + calldata: Array::, + deploy_from_zero: bool, + ) { + syscalls::deploy_syscall( + class_hash, contract_address_salt, calldata.span(), deploy_from_zero + ) + .unwrap_syscall(); + } + + + #[external(v0)] + fn test_keccak(ref self: ContractState) { + let mut input: Array:: = Default::default(); + input.append(u256 { low: 1, high: 0 }); + + let res = keccak::keccak_u256s_le_inputs(input.span()); + assert(res.low == 0x587f7cc3722e9654ea3963d5fe8c0748, 'Wrong hash value'); + assert(res.high == 0xa5963aa610cb75ba273817bce5f8c48f, 'Wrong hash value'); + + let mut input: Array:: = Default::default(); + input.append(1_u64); + match syscalls::keccak_syscall(input.span()) { + Result::Ok(_) => panic_with_felt252('Should fail'), + Result::Err(revert_reason) => assert( + *revert_reason.at(0) == 'Invalid input length', 'Wrong error msg' + ), + } + } + + #[external(v0)] + fn test_sha256(ref self: ContractState) { + let mut input: Array:: = Default::default(); + input.append('aaaa'); + + // Test the sha256 syscall computation of the string 'aaaa'. + let [res, _, _, _, _, _, _, _,] = compute_sha256_u32_array(input, 0, 0); + assert(res == 0x61be55a8, 'Wrong hash value'); + } + + #[external(v0)] + fn test_secp256k1(ref self: ContractState) { + // Test a point not on the curve. + assert( + starknet::secp256k1::secp256k1_new_syscall(x: 0, y: 1).unwrap_syscall().is_none(), + 'Should be none' + ); + + let secp256k1_prime = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f; + match starknet::secp256k1::secp256k1_new_syscall(x: secp256k1_prime, y: 1) { + Result::Ok(_) => panic_with_felt252('Should fail'), + Result::Err(revert_reason) => assert( + *revert_reason.at(0) == 'Invalid argument', 'Wrong error msg' + ), + } + + // Test a point on the curve. + let x = 0xF728B4FA42485E3A0A5D2F346BAA9455E3E70682C2094CAC629F6FBED82C07CD; + let y = 0x8E182CA967F38E1BD6A49583F43F187608E031AB54FC0C4A8F0DC94FAD0D0611; + let p0 = starknet::secp256k1::secp256k1_new_syscall(x, y).unwrap_syscall().unwrap(); + + let (x_coord, y_coord) = starknet::secp256k1::secp256k1_get_xy_syscall(p0).unwrap_syscall(); + assert(x_coord == x && y_coord == y, 'Unexpected coordinates'); + + let (msg_hash, signature, _expected_public_key_x, _expected_public_key_y, eth_address) = + get_message_and_secp256k1_signature(); + verify_eth_signature(:msg_hash, :signature, :eth_address); + } + + /// Returns a golden valid message hash and its signature, for testing. + fn get_message_and_secp256k1_signature() -> (u256, Signature, u256, u256, EthAddress) { + let msg_hash = 0xe888fbb4cf9ae6254f19ba12e6d9af54788f195a6f509ca3e934f78d7a71dd85; + let r = 0x4c8e4fbc1fbb1dece52185e532812c4f7a5f81cf3ee10044320a0d03b62d3e9a; + let s = 0x4ac5e5c0c0e8a4871583cc131f35fb49c2b7f60e6a8b84965830658f08f7410c; + + let (public_key_x, public_key_y) = ( + 0xa9a02d48081294b9bb0d8740d70d3607feb20876964d432846d9b9100b91eefd, + 0x18b410b5523a1431024a6ab766c89fa5d062744c75e49efb9925bf8025a7c09e + ); + + let eth_address = 0x767410c1bb448978bd42b984d7de5970bcaf5c43_u256.into(); + + (msg_hash, Signature { r, s, y_parity: true }, public_key_x, public_key_y, eth_address) + } + + + #[external(v0)] + fn test_secp256r1(ref self: ContractState) { + // Test a point not on the curve. + assert( + starknet::secp256r1::secp256r1_new_syscall(x: 0, y: 1).unwrap_syscall().is_none(), + 'Should be none' + ); + + let secp256r1_prime = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff; + match starknet::secp256r1::secp256r1_new_syscall(x: secp256r1_prime, y: 1) { + Result::Ok(_) => panic_with_felt252('Should fail'), + Result::Err(revert_reason) => assert( + *revert_reason.at(0) == 'Invalid argument', 'Wrong error msg' + ), + } + + // Test a point on the curve. + let x = 0x502A43CE77C6F5C736A82F847FA95F8C2D483FE223B12B91047D83258A958B0F; + let y = 0xDB0A2E6710C71BA80AFEB3ABDF69D306CE729C7704F4DDF2EAAF0B76209FE1B0; + let p0 = starknet::secp256r1::secp256r1_new_syscall(x, y).unwrap_syscall().unwrap(); + + let (x_coord, y_coord) = starknet::secp256r1::secp256r1_get_xy_syscall(p0).unwrap_syscall(); + assert(x_coord == x && y_coord == y, 'Unexpected coordinates'); + + let (msg_hash, signature, expected_public_key_x, expected_public_key_y, _eth_address) = + get_message_and_secp256r1_signature(); + let public_key = Secp256r1Impl::secp256_ec_new_syscall( + expected_public_key_x, expected_public_key_y + ) + .unwrap_syscall() + .unwrap(); + is_valid_signature::(msg_hash, signature.r, signature.s, public_key); + } + + + /// Returns a golden valid message hash and its signature, for testing. + fn get_message_and_secp256r1_signature() -> (u256, Signature, u256, u256, EthAddress) { + let msg_hash = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855; + let r = 0xb292a619339f6e567a305c951c0dcbcc42d16e47f219f9e98e76e09d8770b34a; + let s = 0x177e60492c5a8242f76f07bfe3661bde59ec2a17ce5bd2dab2abebdf89a62e2; + + let (public_key_x, public_key_y) = ( + 0x04aaec73635726f213fb8a9e64da3b8632e41495a944d0045b522eba7240fad5, + 0x0087d9315798aaa3a5ba01775787ced05eaaf7b4e09fc81d6d1aa546e8365d525d + ); + let eth_address = 0x492882426e1cda979008bfaf874ff796eb3bb1c0_u256.into(); + + (msg_hash, Signature { r, s, y_parity: true }, public_key_x, public_key_y, eth_address) + } + + impl ResourceBoundsPartialEq of PartialEq { + #[inline(always)] + fn eq(lhs: @ResourceBounds, rhs: @ResourceBounds) -> bool { + (*lhs.resource == *rhs.resource) + && (*lhs.max_amount == *rhs.max_amount) + && (*lhs.max_price_per_unit == *rhs.max_price_per_unit) + } + #[inline(always)] + fn ne(lhs: @ResourceBounds, rhs: @ResourceBounds) -> bool { + !(*lhs == *rhs) + } + } + + impl TxInfoPartialEq of PartialEq { + #[inline(always)] + fn eq(lhs: @TxInfo, rhs: @TxInfo) -> bool { + (*lhs.version == *rhs.version) + && (*lhs.account_contract_address == *rhs.account_contract_address) + && (*lhs.max_fee == *rhs.max_fee) + && (*lhs.signature == *rhs.signature) + && (*lhs.transaction_hash == *rhs.transaction_hash) + && (*lhs.chain_id == *rhs.chain_id) + && (*lhs.nonce == *rhs.nonce) + && (*lhs.resource_bounds == *rhs.resource_bounds) + && (*lhs.tip == *rhs.tip) + && (*lhs.paymaster_data == *rhs.paymaster_data) + && (*lhs.nonce_data_availability_mode == *rhs.nonce_data_availability_mode) + && (*lhs.fee_data_availability_mode == *rhs.fee_data_availability_mode) + && (*lhs.account_deployment_data == *rhs.account_deployment_data) + } + #[inline(always)] + fn ne(lhs: @TxInfo, rhs: @TxInfo) -> bool { + !(*lhs == *rhs) + } + } + + impl BlockInfoPartialEq of PartialEq { + #[inline(always)] + fn eq(lhs: @BlockInfo, rhs: @BlockInfo) -> bool { + (*lhs.block_number == *rhs.block_number) + && (*lhs.block_timestamp == *rhs.block_timestamp) + && (*lhs.sequencer_address == *rhs.sequencer_address) + } + #[inline(always)] + fn ne(lhs: @BlockInfo, rhs: @BlockInfo) -> bool { + !(*lhs == *rhs) + } + } + + #[external(v0)] + fn assert_eq(ref self: ContractState, x: felt252, y: felt252) -> felt252 { + assert(x == y, 'x != y'); + 'success' + } + + #[external(v0)] + fn invoke_call_chain(ref self: ContractState, mut call_chain: Array::,) -> felt252 { + // If the chain is too short, fail with division by zero. + let len = call_chain.len(); + if len < 3 { + return (1_u8 / 0_u8).into(); + } + + // Pop the parameters for the next call in the chain. + let contract_id = call_chain.pop_front().unwrap(); + let function_selector = call_chain.pop_front().unwrap(); + let call_type = call_chain.pop_front().unwrap(); + + // Choose call type according to the following options: + // 0 - call contract syscall. 1 - library call syscall. other - regular inner call. + // The remaining items of the call_chain array are passed on as calldata. + if call_type == 0 { + let contract_address = contract_address_try_from_felt252(contract_id).unwrap(); + syscalls::call_contract_syscall(contract_address, function_selector, call_chain.span()) + .unwrap_syscall(); + } else if call_type == 1 { + let class_hash = class_hash_try_from_felt252(contract_id).unwrap(); + syscalls::library_call_syscall(class_hash, function_selector, call_chain.span()) + .unwrap_syscall(); + } else { + let invoke_call_chain_selector: felt252 = + 0x0062c83572d28cb834a3de3c1e94977a4191469a4a8c26d1d7bc55305e640ed5; + let fail_selector: felt252 = + 0x032564d7e0fe091d49b4c20f4632191e4ed6986bf993849879abfef9465def25; + if function_selector == invoke_call_chain_selector { + return invoke_call_chain(ref self, call_chain); + } + if function_selector == fail_selector { + fail(ref self); + } + } + return 0; + } + + #[external(v0)] + fn fail(ref self: ContractState) { + panic_with_felt252('fail'); + } + + #[external(v0)] + fn recursive_fail(ref self: ContractState, depth: felt252) { + if depth == 0 { + panic_with_felt252('recursive_fail'); + } + recursive_fail(ref self, depth - 1) + } + + #[external(v0)] + fn recurse(ref self: ContractState, depth: felt252) { + if depth == 0 { + return; + } + recurse(ref self, depth - 1) + } + + #[external(v0)] + fn recursive_syscall( + ref self: ContractState, + contract_address: ContractAddress, + function_selector: felt252, + depth: felt252, + ) { + if depth == 0 { + return; + } + let calldata: Array:: = array![ + contract_address.into(), function_selector, depth - 1 + ]; + syscalls::call_contract_syscall(contract_address, function_selector, calldata.span()) + .unwrap_syscall(); + return; + } + + #[derive(Drop, Serde)] + struct IndexAndValues { + index: felt252, + values: (u128, u128), + } + + #[starknet::interface] + trait MyContract { + fn xor_counters(ref self: TContractState, index_and_x: IndexAndValues); + } + + // Advances the 'two_counters' storage variable by 'diff'. + #[external(v0)] + fn advance_counter(ref self: ContractState, index: felt252, diff_0: felt252, diff_1: felt252) { + let val = self.two_counters.read(index); + let (val_0, val_1) = val; + self.two_counters.write(index, (val_0 + diff_0, val_1 + diff_1)); + } + + #[external(v0)] + fn xor_counters(ref self: ContractState, index_and_x: IndexAndValues) { + let index = index_and_x.index; + let (val_0, val_1) = index_and_x.values; + let counters = self.two_counters.read(index); + let (counter_0, counter_1) = counters; + let counter_0: u128 = counter_0.try_into().unwrap(); + let counter_1: u128 = counter_1.try_into().unwrap(); + let res_0: felt252 = (counter_0 ^ val_0).into(); + let res_1: felt252 = (counter_1 ^ val_1).into(); + self.two_counters.write(index, (res_0, res_1)); + } + + #[external(v0)] + fn call_xor_counters( + ref self: ContractState, address: ContractAddress, index_and_x: IndexAndValues + ) { + MyContractDispatcher { contract_address: address }.xor_counters(index_and_x); + } + + #[external(v0)] + fn test_ec_op(ref self: ContractState) { + let p = EcPointTrait::new( + 0x654fd7e67a123dd13868093b3b7777f1ffef596c2e324f25ceaf9146698482c, + 0x4fad269cbf860980e38768fe9cb6b0b9ab03ee3fe84cfde2eccce597c874fd8 + ) + .unwrap(); + let q = EcPointTrait::new( + 0x3dbce56de34e1cfe252ead5a1f14fd261d520d343ff6b7652174e62976ef44d, + 0x4b5810004d9272776dec83ecc20c19353453b956e594188890b48467cb53c19 + ) + .unwrap(); + let m: felt252 = 0x6d232c016ef1b12aec4b7f88cc0b3ab662be3b7dd7adbce5209fcfdbd42a504; + let res = q.mul(m) + p; + let res_nz = res.try_into().unwrap(); + self.ec_point.write(res_nz.coordinates()); + } + + #[external(v0)] + fn add_signature_to_counters(ref self: ContractState, index: felt252) { + let signature = get_execution_info().unbox().tx_info.unbox().signature; + let val = self.two_counters.read(index); + let (val_0, val_1) = val; + self.two_counters.write(index, (val_0 + *signature.at(0), val_1 + *signature.at(1))); + } + + #[external(v0)] + fn send_message(self: @ContractState, to_address: felt252) { + let mut payload = ArrayTrait::::new(); + payload.append(12); + payload.append(34); + starknet::send_message_to_l1_syscall(to_address, payload.span()).unwrap_syscall(); + } + + #[external(v0)] + fn test_circuit(ref self: ContractState) { + let in1 = CircuitElement::> {}; + let in2 = CircuitElement::> {}; + let add = circuit_add(in1, in2); + let inv = circuit_inverse(add); + let sub = circuit_sub(inv, in2); + let mul = circuit_mul(inv, sub); + + let modulus = TryInto::<_, CircuitModulus>::try_into([7, 0, 0, 0]).unwrap(); + let outputs = + (mul,).new_inputs().next([3, 0, 0, 0]).next([6, 0, 0, 0]).done().eval(modulus).unwrap(); + + assert!(outputs.get_output(mul) == u384 { limb0: 6, limb1: 0, limb2: 0, limb3: 0 }); + } + + // Add drop for these objects as they only have PanicDestruct. + impl AddInputResultDrop of Drop>; + impl CircuitDataDrop of Drop>; + impl CircuitInputAccumulatorDrop of Drop>; + + #[external(v0)] + fn test_rc96_holes(ref self: ContractState) { + test_rc96_holes_helper(); + test_rc96_holes_helper(); + } + + #[inline(never)] + fn test_rc96_holes_helper() { + let in1 = CircuitElement::> {}; + (in1,).new_inputs().next([3, 0, 0, 0]); + } + + #[external(v0)] + fn test_call_contract_revert( + ref self: ContractState, + contract_address: ContractAddress, + entry_point_selector: felt252, + calldata: Array:: + ) { + match syscalls::call_contract_syscall( + contract_address, entry_point_selector, calldata.span()) + { + Result::Ok(_) => panic!("Expected revert"), + Result::Err(errors) => { + let mut error_span = errors.span(); + assert( + *error_span.pop_back().unwrap() == 'ENTRYPOINT_FAILED', + 'Unexpected error', + ); + }, + }; + // TODO(Yoni, 1/12/2024): test replace class once get_class_hash_at syscall is supported. + assert(self.my_storage_var.read() == 0, 'values should not change.'); + } +} diff --git a/crates/blockifier/feature_contracts/cairo1/compiled/cairo_steps_test_contract.casm.json b/crates/blockifier/feature_contracts/cairo1/compiled/cairo_steps_test_contract.casm.json new file mode 100644 index 00000000000..dc42e7db38a --- /dev/null +++ b/crates/blockifier/feature_contracts/cairo1/compiled/cairo_steps_test_contract.casm.json @@ -0,0 +1,36214 @@ +{ + "prime": "0x800000000000011000000000000000000000000000000000000000000000001", + "compiler_version": "2.7.0", + "bytecode": [ + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0xdd", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xb2", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0xa0", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x73", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127fea7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x4ab8", + "0x482480017fff8000", + "0x4ab7", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fe8", + "0x42fe", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff27fff", + "0x10780017fff7fff", + "0x43", + "0x4824800180007fe8", + "0x42fe", + "0x400080007ff37fff", + "0x480680017fff8000", + "0x0", + "0x482480017ff28000", + "0x1", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280007ffb7fff", + "0x400280017ffb7ffc", + "0x400280027ffb7ffd", + "0x400280037ffb7fea", + "0x400280047ffb7ff5", + "0x480280067ffb8000", + "0x20680017fff7fff", + "0x23", + "0x480280057ffb8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400280077ffb7fff", + "0x400280087ffb7ffd", + "0x400280097ffb7ffe", + "0x4002800a7ffb7fe6", + "0x4802800c7ffb8000", + "0x20680017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x4802800d7ffb8000", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x4802800b7ffb8000", + "0x482680017ffb8000", + "0xe", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x4802800b7ffb8000", + "0x482680017ffb8000", + "0xf", + "0x4802800d7ffb8000", + "0x4802800e7ffb8000", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x4", + "0x480280057ffb8000", + "0x482680017ffb8000", + "0x9", + "0x480280077ffb8000", + "0x480280087ffb8000", + "0x48127ff57fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff08000", + "0x1", + "0x48127fe37fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0xa0", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x4a09", + "0x482480017fff8000", + "0x4a08", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff8", + "0x3e4e", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0x6b", + "0x4824800180007ff8", + "0x3e4e", + "0x400080007ff87fff", + "0x480680017fff8000", + "0xf", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080017ff37ffc", + "0x480080027ff27ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080037ff17ffd", + "0x10780017fff7fff", + "0x44", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080017ff47ffd", + "0x480080027ff37ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080037ff27ffe", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x482480017ff08000", + "0x4", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280007ffb7fff", + "0x400280017ffb7ff5", + "0x400280027ffb7ffc", + "0x400280037ffb7ff6", + "0x400280047ffb7ffd", + "0x480280067ffb8000", + "0x20680017fff7fff", + "0x24", + "0x480280057ffb8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280077ffb7fff", + "0x400280087ffb7ffc", + "0x400280097ffb7ffd", + "0x4002800a7ffb7ff1", + "0x4002800b7ffb7ffe", + "0x4802800d7ffb8000", + "0x20680017fff7fff", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127ff77fff8000", + "0x4802800c7ffb8000", + "0x482680017ffb8000", + "0xe", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff87fff8000", + "0x4802800c7ffb8000", + "0x482680017ffb8000", + "0x10", + "0x4802800e7ffb8000", + "0x4802800f7ffb8000", + "0x10780017fff7fff", + "0x16", + "0x48127ffd7fff8000", + "0x480280057ffb8000", + "0x482680017ffb8000", + "0x9", + "0x480280077ffb8000", + "0x480280087ffb8000", + "0x10780017fff7fff", + "0xe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x4", + "0x48127ff57fff8000", + "0x480a7ffb7fff8000", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x48127ff37fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x10d", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xe2", + "0x40137fff7fff8001", + "0xa0680017fff8004", + "0xe", + "0x4825800180048001", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0xcf", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48317fff80008001", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xa2", + "0x40137fff7fff8000", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff47fff8000", + "0x48127fe77fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x1a42", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff57fff8000", + "0x48127fe87fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0x54", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x48d0", + "0x482480017fff8000", + "0x48cf", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff4", + "0x28b4", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff17fff", + "0x10780017fff7fff", + "0x24", + "0x4824800180007ff4", + "0x28b4", + "0x400080007ff27fff", + "0x482480017ff28000", + "0x1", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x400280007ffb7fff", + "0x400280017ffb7ffd", + "0x400380027ffb8001", + "0x400380037ffb8000", + "0x400280047ffb7ff5", + "0x400280057ffb7ff6", + "0x480280077ffb8000", + "0x20680017fff7fff", + "0xb", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480680017fff8000", + "0x0", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x1", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x9", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0xffffffffffffffffffffffffffffe35e", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x21c", + "0x4825800180007ffa", + "0x1ca2", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x1f1", + "0x40137fff7fff8008", + "0xa0680017fff8004", + "0xe", + "0x4825800180048008", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0x1de", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48317fff80008008", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x1b1", + "0x40137fff7fff8003", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff47fff8000", + "0x48127fe77fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x191f", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff57fff8000", + "0x48127fe87fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0x163", + "0x40137ffe7fff8005", + "0x40137fff7fff8006", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffa8000", + "0x1", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff78000", + "0x10780017fff7fff", + "0x8", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x13b", + "0x40137fff7fff8007", + "0xa0680017fff8004", + "0xe", + "0x4825800180048007", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff07ffc", + "0x480080017fef7ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027fee7ffd", + "0x10780017fff7fff", + "0x128", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48317fff80008007", + "0x480080007ff17ffd", + "0x480080017ff07ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027fef7ffe", + "0x482480017fef8000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xfb", + "0x40137fff7fff8004", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff47fff8000", + "0x48127fe37fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x189a", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff57fff8000", + "0x48127fe47fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0xad", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x4728", + "0x482480017fff8000", + "0x4727", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff4", + "0x70d0", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff17fff", + "0x10780017fff7fff", + "0x7d", + "0x4824800180007ff4", + "0x70d0", + "0x400080007ff27fff", + "0x482480017ff28000", + "0x1", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x400280007ffb7fff", + "0x400280017ffb7ffd", + "0x400380027ffb8008", + "0x400380037ffb8003", + "0x400380047ffb8005", + "0x400380057ffb8006", + "0x480280077ffb8000", + "0x20680017fff7fff", + "0x5f", + "0x480280067ffb8000", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x4002800a7ffb7fff", + "0x4002800b7ffb7ffc", + "0x4003800c7ffb8007", + "0x4003800d7ffb8004", + "0x4002800e7ffb7ff0", + "0x4002800f7ffb7ff1", + "0x480280117ffb8000", + "0x20680017fff7fff", + "0x49", + "0x40780017fff7fff", + "0x1", + "0x48127ff77fff8000", + "0x480280107ffb8000", + "0x48127ffd7fff8000", + "0x48127ffc7fff8000", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x402780017ffb8000", + "0x14", + "0x400380127ffb8001", + "0x400380137ffb8002", + "0x1104800180018000", + "0x188a", + "0x20680017fff7ffd", + "0x32", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480a80017fff8000", + "0x480a80027fff8000", + "0x1104800180018000", + "0x1880", + "0x20680017fff7ffd", + "0x21", + "0x40780017fff7fff", + "0x1", + "0x48307ffd80007ffe", + "0x400080007ffe7fff", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x1104800180018000", + "0x18b3", + "0x20680017fff7ffd", + "0xa", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a80007fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a80007fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a80007fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x10780017fff7fff", + "0x17", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a80007fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x10780017fff7fff", + "0x10", + "0x48127ff87fff8000", + "0x480280107ffb8000", + "0x482680017ffb8000", + "0x14", + "0x480280127ffb8000", + "0x480280137ffb8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x1", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202336", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202335", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127fe77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017fee8000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127fee7fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202334", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x97", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x6c", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0x5a", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x45d3", + "0x482480017fff8000", + "0x45d2", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fed", + "0x9e66", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0x20", + "0x4824800180007fed", + "0x9e66", + "0x400080007ff87fff", + "0x482480017ff88000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x48127fef7fff8000", + "0x1104800180018000", + "0x17db", + "0x20680017fff7ffd", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x48127fe87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0xfffffffffffffffffffffffffffff36c", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x13a", + "0x4825800180007ffa", + "0xc94", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x10f", + "0x400180007fff8000", + "0xa0680017fff8000", + "0x12", + "0x4825800180008000", + "0x10000000000000000", + "0x4844800180008002", + "0x8000000000000110000000000000000", + "0x4830800080017ffe", + "0x480080007ff67fff", + "0x482480017ffe8000", + "0xefffffffffffffdeffffffffffffffff", + "0x480080017ff47fff", + "0x400080027ff37ffb", + "0x402480017fff7ffb", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7fff", + "0xfa", + "0x402780017fff7fff", + "0x1", + "0x400180007ff98000", + "0x4826800180008000", + "0xffffffffffffffff0000000000000000", + "0x400080017ff87fff", + "0x482480017ff88000", + "0x2", + "0x48307ff980007ffa", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff88000", + "0x1", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff57fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff97fff8000", + "0x48127fef7fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x1658", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff07fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0xa5", + "0x40137ffe7fff8001", + "0x40137fff7fff8002", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffa8000", + "0x1", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff77fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff37fff8000", + "0x48127ff37fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x1617", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0x56", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x44a5", + "0x482480017fff8000", + "0x44a4", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff4", + "0x87a", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff17fff", + "0x10780017fff7fff", + "0x26", + "0x4824800180007ff4", + "0x87a", + "0x400080007ff27fff", + "0x482480017ff28000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff37fff8000", + "0x48127ff37fff8000", + "0x480a80007fff8000", + "0x480a80017fff8000", + "0x480a80027fff8000", + "0x1104800180018000", + "0x1725", + "0x20680017fff7ffd", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x1", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff38000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x7", + "0x48127ff37fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fee7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x9e", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x73", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x12", + "0x4824800180007ffe", + "0x10000000000000000", + "0x4844800180008002", + "0x8000000000000110000000000000000", + "0x4830800080017ffe", + "0x480080007ff57fff", + "0x482480017ffe8000", + "0xefffffffffffffdeffffffffffffffff", + "0x480080017ff37fff", + "0x400080027ff27ffb", + "0x402480017fff7ffb", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7fff", + "0x5e", + "0x402780017fff7fff", + "0x1", + "0x400080007ff87ffe", + "0x482480017ffe8000", + "0xffffffffffffffff0000000000000000", + "0x400080017ff77fff", + "0x482480017ff78000", + "0x2", + "0x48307ff880007ff9", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x48127ff17fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x43d7", + "0x482480017fff8000", + "0x43d6", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fef", + "0x1248", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0x26", + "0x4824800180007fef", + "0x1248", + "0x400080007ff87fff", + "0x482480017ff88000", + "0x1", + "0x480680017fff8000", + "0x476574426c6f636b48617368", + "0x400280007ffb7fff", + "0x400280017ffb7ffd", + "0x400280027ffb7ff3", + "0x480280047ffb8000", + "0x20680017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480280057ffb8000", + "0x400080007ffe7fff", + "0x48127ffb7fff8000", + "0x480280037ffb8000", + "0x482680017ffb8000", + "0x6", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480280037ffb8000", + "0x482680017ffb8000", + "0x7", + "0x480680017fff8000", + "0x1", + "0x480280057ffb8000", + "0x480280067ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x48127fea7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff28000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x8", + "0x48127ff27fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fed7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0xffffffffffffffffffffffffffff72ac", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x10b", + "0x4825800180007ffa", + "0x8d54", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x1668", + "0x20680017fff7ffc", + "0xf2", + "0x48127ff97fff8000", + "0x48127fd57fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x40137ff97fff8000", + "0x40137ffa7fff8001", + "0x40137ffb7fff8002", + "0x1104800180018000", + "0x172a", + "0x20680017fff7feb", + "0xdf", + "0x20680017fff7fee", + "0xcf", + "0x48307fec80007fed", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017feb8000", + "0x1", + "0x48127feb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007fe88000", + "0x10780017fff7fff", + "0x8", + "0x48127feb7fff8000", + "0x48127feb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xac", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x89", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x66", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127fd77fff8000", + "0x48127fd77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x42ff", + "0x482480017fff8000", + "0x42fe", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fd5", + "0x8070", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007fd27fff", + "0x10780017fff7fff", + "0x36", + "0x4824800180007fd5", + "0x8070", + "0x400080007fd37fff", + "0x482480017fd38000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x480a80007fff8000", + "0x480a80017fff8000", + "0x480a80027fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd37fff8000", + "0x48127fd77fff8000", + "0x48127fdb7fff8000", + "0x48127fdf7fff8000", + "0x1104800180018000", + "0x1b5b", + "0x20680017fff7ffd", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fd08000", + "0x1", + "0x48127fd07fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202335", + "0x400080007ffe7fff", + "0x48127fd87fff8000", + "0x48127fd87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202334", + "0x400080007ffe7fff", + "0x48127fdd7fff8000", + "0x48127fdd7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127fe27fff8000", + "0x48127fe27fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127fe77fff8000", + "0x48127fe77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127fe97fff8000", + "0x48127fe97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127fd37fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x10d", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xe2", + "0x40137fff7fff8001", + "0xa0680017fff8004", + "0xe", + "0x4825800180048001", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0xcf", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48317fff80008001", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xa2", + "0x40137fff7fff8000", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff47fff8000", + "0x48127fe77fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x131f", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff57fff8000", + "0x48127fe87fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0x54", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x41ad", + "0x482480017fff8000", + "0x41ac", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff4", + "0x28b4", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff17fff", + "0x10780017fff7fff", + "0x24", + "0x4824800180007ff4", + "0x28b4", + "0x400080007ff27fff", + "0x482480017ff28000", + "0x1", + "0x480680017fff8000", + "0x4c69627261727943616c6c", + "0x400280007ffb7fff", + "0x400280017ffb7ffd", + "0x400380027ffb8001", + "0x400380037ffb8000", + "0x400280047ffb7ff5", + "0x400280057ffb7ff6", + "0x480280077ffb8000", + "0x20680017fff7fff", + "0xb", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480680017fff8000", + "0x0", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x1", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x119", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xee", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0xdc", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xaf", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x8c", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x69", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x46", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127fe87fff8000", + "0x48127fdb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x408e", + "0x482480017fff8000", + "0x408d", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fd9", + "0x5622", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007fe37fff", + "0x10780017fff7fff", + "0x16", + "0x4824800180007fd9", + "0x5622", + "0x400080007fe47fff", + "0x48127fff7fff8000", + "0x480a7ffb7fff8000", + "0x48127fdc7fff8000", + "0x48127fe67fff8000", + "0x48127fea7fff8000", + "0x48127fee7fff8000", + "0x48127ff27fff8000", + "0x1104800180018000", + "0x1a6e", + "0x482480017fc88000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fe18000", + "0x1", + "0x48127fd47fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202335", + "0x400080007ffe7fff", + "0x48127fe97fff8000", + "0x48127fdc7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202334", + "0x400080007ffe7fff", + "0x48127fee7fff8000", + "0x48127fe17fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127ff37fff8000", + "0x48127fe67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x9a", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x6f", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0x5d", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3fb5", + "0x482480017fff8000", + "0x3fb4", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fed", + "0x128e", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0x23", + "0x4824800180007fed", + "0x128e", + "0x400080007ff87fff", + "0x482480017ff88000", + "0x1", + "0x480680017fff8000", + "0x5265706c616365436c617373", + "0x400280007ffb7fff", + "0x400280017ffb7ffd", + "0x400280027ffb7ff0", + "0x480280047ffb8000", + "0x20680017fff7fff", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x480280037ffb8000", + "0x482680017ffb8000", + "0x5", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480280037ffb8000", + "0x482680017ffb8000", + "0x7", + "0x480680017fff8000", + "0x1", + "0x480280057ffb8000", + "0x480280067ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x48127fe87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0xcb", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xa3", + "0x40137fff7fff8000", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff47fff8000", + "0x48127ff27fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x104f", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff57fff8000", + "0x48127ff37fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0x55", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3edd", + "0x482480017fff8000", + "0x3edc", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff4", + "0x213e", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff17fff", + "0x10780017fff7fff", + "0x25", + "0x4824800180007ff4", + "0x213e", + "0x400080007ff27fff", + "0x482480017ff28000", + "0x1", + "0x480680017fff8000", + "0x53656e644d657373616765546f4c31", + "0x400280007ffb7fff", + "0x400280017ffb7ffd", + "0x400380027ffb8000", + "0x400280037ffb7ff5", + "0x400280047ffb7ff6", + "0x480280067ffb8000", + "0x20680017fff7fff", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x480280057ffb8000", + "0x482680017ffb8000", + "0x7", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480280057ffb8000", + "0x482680017ffb8000", + "0x9", + "0x480680017fff8000", + "0x1", + "0x480280077ffb8000", + "0x480280087ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x1", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x5a", + "0x4825800180007ffa", + "0x0", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x11", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x480a7ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3e52", + "0x482480017fff8000", + "0x3e51", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff8", + "0x41a", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0x23", + "0x4824800180007ff8", + "0x41a", + "0x400080007ff87fff", + "0x48027ffd7ff98000", + "0x48027ffe7ff98000", + "0x48027fff7ff98000", + "0x400280007ff97ffd", + "0x482480017ffe8000", + "0x1", + "0x400280017ff97fff", + "0x400280027ff97ffe", + "0x484480017ffd8000", + "0x3", + "0x48307fff7ffb8000", + "0x482480017ff28000", + "0x1", + "0x482680017ff98000", + "0x3", + "0x48127ff77fff8000", + "0x480080007ffc8000", + "0x1104800180018000", + "0x1870", + "0x40780017fff7fff", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x480a7ff97fff8000", + "0x48127ff27fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0xfffffffffffffffffffffffffffffba0", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x13f", + "0x4825800180007ffa", + "0x460", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x114", + "0x40137fff7fff8001", + "0xa0680017fff8004", + "0xe", + "0x4825800180048001", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0x101", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48317fff80008001", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xd4", + "0x40137fff7fff8000", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff47fff8000", + "0x48127fe77fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0xed1", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff57fff8000", + "0x48127fe87fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0x86", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffa8000", + "0x1", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff77fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x63", + "0x480080007fff8000", + "0x20680017fff7fff", + "0x6", + "0x480680017fff8000", + "0x1", + "0x10780017fff7fff", + "0x4", + "0x480680017fff8000", + "0x0", + "0x48307ffa80007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127fef7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3d41", + "0x482480017fff8000", + "0x3d40", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fed", + "0x2a94", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007fea7fff", + "0x10780017fff7fff", + "0x2a", + "0x4824800180007fed", + "0x2a94", + "0x400080007feb7fff", + "0x480680017fff8000", + "0x1", + "0x48307ff780007fff", + "0x482480017fe98000", + "0x1", + "0x480680017fff8000", + "0x4465706c6f79", + "0x400280007ffb7fff", + "0x400280017ffb7ffb", + "0x400380027ffb8001", + "0x400380037ffb8000", + "0x400280047ffb7fec", + "0x400280057ffb7fed", + "0x400280067ffb7ffd", + "0x480280087ffb8000", + "0x20680017fff7fff", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x480280077ffb8000", + "0x482680017ffb8000", + "0xc", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480280077ffb8000", + "0x482680017ffb8000", + "0xb", + "0x480680017fff8000", + "0x1", + "0x480280097ffb8000", + "0x4802800a7ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fe88000", + "0x1", + "0x48127fe87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202334", + "0x400080007ffe7fff", + "0x48127ff27fff8000", + "0x48127ff27fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x54", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3c8f", + "0x482480017fff8000", + "0x3c8e", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff8", + "0x76ca", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0x1f", + "0x4824800180007ff8", + "0x76ca", + "0x400080007ff87fff", + "0x482480017ff88000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x1778", + "0x20680017fff7ffd", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x48127ff37fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x54", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3c27", + "0x482480017fff8000", + "0x3c26", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff8", + "0x3c5a", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0x1f", + "0x4824800180007ff8", + "0x3c5a", + "0x400080007ff87fff", + "0x482480017ff88000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x17e4", + "0x20680017fff7ffd", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x48127ff37fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x5c", + "0x4825800180007ffa", + "0x0", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x11", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x480a7ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3bbe", + "0x482480017fff8000", + "0x3bbd", + "0x480080007fff8000", + "0x480080017fff8000", + "0x484480017fff8000", + "0x8", + "0x482480017fff8000", + "0x4142e", + "0xa0680017fff8000", + "0x8", + "0x48307ffe80007ff5", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff47fff", + "0x10780017fff7fff", + "0x21", + "0x48307ffe80007ff5", + "0x400080007ff57fff", + "0x482480017ff58000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x17ca", + "0x20680017fff7ffd", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff77fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff28000", + "0x1", + "0x480a7ff97fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x54", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3b4e", + "0x482480017fff8000", + "0x3b4d", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff8", + "0x382d4", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0x1f", + "0x4824800180007ff8", + "0x382d4", + "0x400080007ff87fff", + "0x482480017ff88000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x18be", + "0x20680017fff7ffd", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x48127ff37fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0xa1", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x79", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x56", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff27fff8000", + "0x48127ff07fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3abc", + "0x482480017fff8000", + "0x3abb", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fee", + "0x0", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007fed7fff", + "0x10780017fff7fff", + "0x26", + "0x4824800180007fee", + "0x0", + "0x400080007fee7fff", + "0x48307ff880007ff3", + "0x482480017fed8000", + "0x1", + "0x20680017fff7ffe", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x73756363657373", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7820213d2079", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017feb8000", + "0x1", + "0x48127fe97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff37fff8000", + "0x48127ff17fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0xa5", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff97fff8000", + "0x48127ff77fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0xb64", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0x53", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x39f2", + "0x482480017fff8000", + "0x39f1", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff4", + "0x0", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff17fff", + "0x10780017fff7fff", + "0x23", + "0x4824800180007ff4", + "0x0", + "0x400080007ff27fff", + "0x482480017ff28000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x1104800180018000", + "0x18e9", + "0x20680017fff7ffd", + "0xe", + "0x40780017fff7fff", + "0x1", + "0x400080007fff7ffe", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x1", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x49", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3978", + "0x482480017fff8000", + "0x3977", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff8", + "0x0", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0x14", + "0x4824800180007ff8", + "0x0", + "0x400080007ff87fff", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x6661696c", + "0x400080007ffe7fff", + "0x482480017ff68000", + "0x1", + "0x48127ffc7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x48127ff37fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x77", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x4f", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff57fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3906", + "0x482480017fff8000", + "0x3905", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff3", + "0x0", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff27fff", + "0x10780017fff7fff", + "0x1f", + "0x4824800180007ff3", + "0x0", + "0x400080007ff37fff", + "0x482480017ff38000", + "0x1", + "0x48127ffe7fff8000", + "0x48127ff67fff8000", + "0x1104800180018000", + "0x194e", + "0x20680017fff7ffd", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff08000", + "0x1", + "0x48127fee7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x77", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x4f", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff57fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x387b", + "0x482480017fff8000", + "0x387a", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff3", + "0x0", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff27fff", + "0x10780017fff7fff", + "0x1f", + "0x4824800180007ff3", + "0x0", + "0x400080007ff37fff", + "0x482480017ff38000", + "0x1", + "0x48127ffe7fff8000", + "0x48127ff67fff8000", + "0x1104800180018000", + "0x18f3", + "0x20680017fff7ffd", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff08000", + "0x1", + "0x48127fee7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0xf7", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xcc", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0xba", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x8d", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x6a", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff27fff8000", + "0x48127fe57fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x37ae", + "0x482480017fff8000", + "0x37ad", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fe3", + "0x1de2", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007fed7fff", + "0x10780017fff7fff", + "0x3a", + "0x4824800180007fe3", + "0x1de2", + "0x400080007fee7fff", + "0x482480017fee8000", + "0x1", + "0x20680017fff7ff7", + "0x8", + "0x40780017fff7fff", + "0x6", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x10780017fff7fff", + "0x1a", + "0x40780017fff7fff", + "0x1", + "0x400080007fff7fe6", + "0x400080017fff7ff1", + "0x4824800180007ff6", + "0x1", + "0x400080027ffe7fff", + "0x48127ffe7fff8000", + "0x482480017ffd8000", + "0x3", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x400280007ffb7fff", + "0x400280017ffb7ff9", + "0x400280027ffb7fe2", + "0x400280037ffb7fed", + "0x400280047ffb7ffd", + "0x400280057ffb7ffe", + "0x480280077ffb8000", + "0x20680017fff7fff", + "0xf", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x40780017fff7fff", + "0x1", + "0x48127ff67fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017feb8000", + "0x1", + "0x48127fde7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127ff37fff8000", + "0x48127fe67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0xcb", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xa2", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x7e", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x5a", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x11", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x480a7ff87fff8000", + "0x48127fec7fff8000", + "0x48127fea7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x36ba", + "0x482480017fff8000", + "0x36b9", + "0x480080007fff8000", + "0x480080007fff8000", + "0x484480017fff8000", + "0x2", + "0x482480017fff8000", + "0xb068", + "0xa0680017fff8000", + "0x8", + "0x48307ffe80007fe6", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007fe57fff", + "0x10780017fff7fff", + "0x24", + "0x48307ffe80007fe6", + "0x400080007fe67fff", + "0x482480017fe68000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ff87fff8000", + "0x480a7ffb7fff8000", + "0x48127fe77fff8000", + "0x48127feb7fff8000", + "0x48127fef7fff8000", + "0x1104800180018000", + "0x1757", + "0x20680017fff7ffd", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127ffa7fff8000", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x480a7ff87fff8000", + "0x482480017fe28000", + "0x1", + "0x48127fe07fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x480a7ff87fff8000", + "0x48127fed7fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x480a7ff87fff8000", + "0x48127ff27fff8000", + "0x48127ff07fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x480a7ff87fff8000", + "0x48127ff77fff8000", + "0x48127ff57fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x480a7ff87fff8000", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x7e", + "0x4825800180007ffa", + "0x0", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x17a7", + "0x20680017fff7ffc", + "0x63", + "0x48307ffa80007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x12", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x480a7ff77fff8000", + "0x48127ff57fff8000", + "0x480a7ff97fff8000", + "0x48127fce7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3612", + "0x482480017fff8000", + "0x3611", + "0x480080007fff8000", + "0x480080007fff8000", + "0x484480017fff8000", + "0x2", + "0x482480017fff8000", + "0xc6c0", + "0x480080017ffc8000", + "0x484480017fff8000", + "0x2", + "0x48307ffd7fff8000", + "0xa0680017fff8000", + "0x8", + "0x48307ffe80007fc8", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007feb7fff", + "0x10780017fff7fff", + "0x27", + "0x48307ffe80007fc8", + "0x400080007fec7fff", + "0x482480017fec8000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ff97fff8000", + "0x480a7ff77fff8000", + "0x480a7ffb7fff8000", + "0x48127feb7fff8000", + "0x48127feb7fff8000", + "0x48127feb7fff8000", + "0x1104800180018000", + "0x1831", + "0x20680017fff7ffd", + "0xe", + "0x40780017fff7fff", + "0x1", + "0x48127ffa7fff8000", + "0x48127ff67fff8000", + "0x48127ff77fff8000", + "0x48127ff57fff8000", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ff77fff8000", + "0x48127ff87fff8000", + "0x48127ff67fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x480a7ff77fff8000", + "0x482480017fe88000", + "0x1", + "0x480a7ff97fff8000", + "0x48127fc17fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x480a7ff77fff8000", + "0x48127ff67fff8000", + "0x480a7ff97fff8000", + "0x48127fcf7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x480a7ff77fff8000", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0xfffffffffffffffffffffffffffffcc2", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0xbb", + "0x4825800180007ffa", + "0x33e", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x90", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0x7e", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x1104800180018000", + "0x16e6", + "0x20680017fff7ffc", + "0x60", + "0x48307ffa80007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff67fff8000", + "0x48127fc57fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3553", + "0x482480017fff8000", + "0x3552", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fc3", + "0x2c24", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff17fff", + "0x10780017fff7fff", + "0x30", + "0x4824800180007fc3", + "0x2c24", + "0x400080007ff27fff", + "0x40780017fff7fff", + "0x1", + "0x400080007fff7ff5", + "0x400080017fff7ff6", + "0x400080027fff7ff7", + "0x480680017fff8000", + "0x7772be8b80a8a33dc6c1f9a6ab820c02e537c73e859de67f288c70f92571bb", + "0x48127ffe7fff8000", + "0x482480017ffd8000", + "0x3", + "0x482480017fee8000", + "0x1", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x400280007ffb7fff", + "0x400280017ffb7ff9", + "0x400280027ffb7fc2", + "0x400280037ffb7ffb", + "0x400280047ffb7ffc", + "0x400280057ffb7ffd", + "0x480280077ffb8000", + "0x20680017fff7fff", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x1", + "0x48127fbe7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127fc67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x5a", + "0x4825800180007ffa", + "0x0", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x11", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x480a7ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x34b6", + "0x482480017fff8000", + "0x34b5", + "0x480080007fff8000", + "0x480080027fff8000", + "0x482480017fff8000", + "0x6acc", + "0xa0680017fff8000", + "0x8", + "0x48307ffe80007ff6", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff57fff", + "0x10780017fff7fff", + "0x21", + "0x48307ffe80007ff6", + "0x400080007ff67fff", + "0x482480017ff68000", + "0x1", + "0x480a7ff97fff8000", + "0x48127ffd7fff8000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x1801", + "0x20680017fff7ffd", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff38000", + "0x1", + "0x480a7ff97fff8000", + "0x48127ff07fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x81", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x58", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x11", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x480a7ff87fff8000", + "0x48127ff67fff8000", + "0x48127ff47fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3432", + "0x482480017fff8000", + "0x3431", + "0x480080007fff8000", + "0x480080007fff8000", + "0x484480017fff8000", + "0x2", + "0x482480017fff8000", + "0xe164", + "0xa0680017fff8000", + "0x8", + "0x48307ffe80007ff0", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007fef7fff", + "0x10780017fff7fff", + "0x22", + "0x48307ffe80007ff0", + "0x400080007ff07fff", + "0x482480017ff08000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ff87fff8000", + "0x480a7ffb7fff8000", + "0x48127ff17fff8000", + "0x1104800180018000", + "0x189c", + "0x20680017fff7ffd", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127ffa7fff8000", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x480a7ff87fff8000", + "0x482480017fec8000", + "0x1", + "0x48127fea7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x480a7ff87fff8000", + "0x48127ff77fff8000", + "0x48127ff57fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x480a7ff87fff8000", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x88", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x60", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff57fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x339d", + "0x482480017fff8000", + "0x339c", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff3", + "0x1220", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff27fff", + "0x10780017fff7fff", + "0x30", + "0x4824800180007ff3", + "0x1220", + "0x400080007ff37fff", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0xc", + "0x400080007ffe7fff", + "0x480680017fff8000", + "0x22", + "0x400080017ffd7fff", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x2", + "0x482480017fee8000", + "0x1", + "0x480680017fff8000", + "0x53656e644d657373616765546f4c31", + "0x400280007ffb7fff", + "0x400280017ffb7ff8", + "0x400280027ffb7ff1", + "0x400280037ffb7ffc", + "0x400280047ffb7ffd", + "0x480280067ffb8000", + "0x20680017fff7fff", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x480280057ffb8000", + "0x482680017ffb8000", + "0x7", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480280057ffb8000", + "0x482680017ffb8000", + "0x9", + "0x480680017fff8000", + "0x1", + "0x480280077ffb8000", + "0x480280087ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff08000", + "0x1", + "0x48127fee7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff67fff", + "0x10780017fff7fff", + "0x69", + "0x4825800180007ffa", + "0x0", + "0x400280007ff67fff", + "0x482680017ff68000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x13", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff77fff8000", + "0x482480017ff68000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3313", + "0x482480017fff8000", + "0x3312", + "0x480080007fff8000", + "0x480080047fff8000", + "0x484480017fff8000", + "0x2", + "0x482480017fff8000", + "0x14160", + "0x480080057ffc8000", + "0x484480017fff8000", + "0x4", + "0x48307ffd7fff8000", + "0xa0680017fff8000", + "0x8", + "0x48307ffe80007ff2", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff17fff", + "0x10780017fff7fff", + "0x26", + "0x48307ffe80007ff2", + "0x400080007ff27fff", + "0x482480017ff28000", + "0x1", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ff77fff8000", + "0x48127ffb7fff8000", + "0x1104800180018000", + "0x18a7", + "0x20680017fff7ffd", + "0xf", + "0x40780017fff7fff", + "0x1", + "0x48127ff77fff8000", + "0x48127ff97fff8000", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x48127ff77fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff87fff8000", + "0x48127ffa7fff8000", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x1", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x48127fea7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff77fff8000", + "0x482480017ff68000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff68000", + "0x1", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff77fff8000", + "0x482480017ff68000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x66", + "0x4825800180007ffa", + "0x0", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x11", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x480a7ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3295", + "0x482480017fff8000", + "0x3294", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff8", + "0x0", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0x2f", + "0x4824800180007ff8", + "0x0", + "0x400080007ff87fff", + "0x480a7ff97fff8000", + "0x1104800180018000", + "0x1a07", + "0x482480017fe88000", + "0x1", + "0x20680017fff7ffc", + "0x17", + "0x48127ffb7fff8000", + "0x1104800180018000", + "0x1a00", + "0x20680017fff7ffd", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x48127fee7fff8000", + "0x48127ffa7fff8000", + "0x48127fdb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffc7fff8000", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x10780017fff7fff", + "0x7", + "0x40780017fff7fff", + "0x10", + "0x48127feb7fff8000", + "0x48127fec7fff8000", + "0x48127fec7fff8000", + "0x48127fec7fff8000", + "0x48127ffc7fff8000", + "0x48127fd97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x480a7ff97fff8000", + "0x48127ff27fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x10c", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xe1", + "0x40137fff7fff8001", + "0xa0680017fff8004", + "0xe", + "0x4825800180048001", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0xce", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48317fff80008001", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x482480017ff58000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xa1", + "0x40137fff7fff8000", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x48127ff47fff8000", + "0x48127fe77fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x308", + "0x20680017fff7ffa", + "0xb", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x14", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff57fff8000", + "0x48127fe87fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0x53", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3196", + "0x482480017fff8000", + "0x3195", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007ff4", + "0x602c", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff17fff", + "0x10780017fff7fff", + "0x23", + "0x4824800180007ff4", + "0x602c", + "0x400080007ff27fff", + "0x482480017ff28000", + "0x1", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x480a80017fff8000", + "0x480a80007fff8000", + "0x48127ff27fff8000", + "0x48127ff27fff8000", + "0x1104800180018000", + "0x1922", + "0x20680017fff7ffd", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017fef8000", + "0x1", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127feb7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x8d", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x65", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x42", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff27fff8000", + "0x48127ff07fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x30cf", + "0x482480017fff8000", + "0x30ce", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fee", + "0x0", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007fed7fff", + "0x10780017fff7fff", + "0x12", + "0x4824800180007fee", + "0x0", + "0x400080007fee7fff", + "0x40780017fff7fff", + "0x1", + "0x400080007fff7ff7", + "0x482480017fed8000", + "0x1", + "0x48127ffd7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017feb8000", + "0x1", + "0x48127fe97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff37fff8000", + "0x48127ff17fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0xe6", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xbe", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x98", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff17ffc", + "0x480080017ff07ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027fef7ffd", + "0x10780017fff7fff", + "0x86", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff27ffd", + "0x480080017ff17ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff07ffe", + "0x482480017ff08000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff28000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x59", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff77fff8000", + "0x48127fe57fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x3001", + "0x482480017fff8000", + "0x3000", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fe3", + "0x1a5e", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff27fff", + "0x10780017fff7fff", + "0x29", + "0x4824800180007fe3", + "0x1a5e", + "0x400080007ff37fff", + "0x480680017fff8000", + "0x0", + "0x482480017ff28000", + "0x1", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280007ffb7fff", + "0x400280017ffb7ffc", + "0x400280027ffb7ffd", + "0x400280037ffb7fea", + "0x400280047ffb7ff5", + "0x480280067ffb8000", + "0x20680017fff7fff", + "0xf", + "0x40780017fff7fff", + "0x1", + "0x400080007fff7ff3", + "0x48127ffc7fff8000", + "0x480280057ffb8000", + "0x482680017ffb8000", + "0x7", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480280057ffb8000", + "0x482680017ffb8000", + "0x9", + "0x480680017fff8000", + "0x1", + "0x480280077ffb8000", + "0x480280087ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017ff08000", + "0x1", + "0x48127fde7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202333", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127fe67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482480017fef8000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127fef7fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127fea7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0x100000000000000000000000000000000", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0xa7", + "0x4825800180007ffa", + "0x0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x7f", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x5c", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e70757420746f6f206c6f6e6720666f7220617267756d656e7473", + "0x400080007ffe7fff", + "0x48127ff27fff8000", + "0x48127ff07fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x2f34", + "0x482480017fff8000", + "0x2f33", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x9", + "0x4824800180007fee", + "0x1414", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007fed7fff", + "0x10780017fff7fff", + "0x2c", + "0x4824800180007fee", + "0x1414", + "0x400080007fee7fff", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1275130f95dda36bcbb6e9d28796c1d7e10b6e9fd5ed083e0ede4b12f613528", + "0x48307ff67ff18000", + "0x482480017feb8000", + "0x1", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280007ffb7fff", + "0x400280017ffb7ffa", + "0x400280027ffb7ffb", + "0x400280037ffb7ffc", + "0x400280047ffb7ffd", + "0x480280067ffb8000", + "0x20680017fff7fff", + "0xf", + "0x40780017fff7fff", + "0x1", + "0x400080007fff7fec", + "0x48127ffc7fff8000", + "0x480280057ffb8000", + "0x482680017ffb8000", + "0x7", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480280057ffb8000", + "0x482680017ffb8000", + "0x9", + "0x480680017fff8000", + "0x1", + "0x480280077ffb8000", + "0x480280087ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482480017feb8000", + "0x1", + "0x48127fe97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202332", + "0x400080007ffe7fff", + "0x48127ff37fff8000", + "0x48127ff17fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4661696c656420746f20646573657269616c697a6520706172616d202331", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127ff67fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ff88000", + "0xfffffffffffffffffffffffffffff6be", + "0x400280007ff77fff", + "0x10780017fff7fff", + "0x43", + "0x4825800180007ff8", + "0x942", + "0x400280007ff77fff", + "0x482680017ff78000", + "0x1", + "0x20780017fff7ffd", + "0xd", + "0x48127fff7fff8000", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x48297ff980007ffa", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ff98000", + "0x10780017fff7fff", + "0x8", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xf", + "0x400280007ffc7fff", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480a7ffb7fff8000", + "0x482680017ffc8000", + "0x1", + "0x4825800180007ffd", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc9", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff78000", + "0x1", + "0x480a7ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ff98000", + "0xfffffffffffffffffffffffffffff722", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x2f", + "0x4825800180007ff9", + "0x8de", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xe", + "0x480080007fff8000", + "0x400280007ffb7fff", + "0x48127ff97fff8000", + "0x48127ff77fff8000", + "0x480a7ffa7fff8000", + "0x482680017ffb8000", + "0x1", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd7", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ff98000", + "0xfffffffffffffffffffffffffffff722", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x2f", + "0x4825800180007ff9", + "0x8de", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffa80007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffa8000", + "0x1", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffa7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xe", + "0x480080007fff8000", + "0x400280007ffd7fff", + "0x48127ff97fff8000", + "0x48127ff77fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffc7fff8000", + "0x482680017ffd8000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd7", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x48127ffe7fff8000", + "0x482480017ffd8000", + "0x1", + "0x480680017fff8000", + "0x456d69744576656e74", + "0x400280007ffc7fff", + "0x400380017ffc7ffb", + "0x400280027ffc7ffd", + "0x400280037ffc7ffe", + "0x400280047ffc7ffd", + "0x400280057ffc7ffe", + "0x480280077ffc8000", + "0x20680017fff7fff", + "0x62", + "0x480280067ffc8000", + "0x480680017fff8000", + "0x5265706c616365436c617373", + "0x400280087ffc7fff", + "0x400280097ffc7ffe", + "0x4003800a7ffc7ffd", + "0x4802800c7ffc8000", + "0x20680017fff7fff", + "0x4e", + "0x4802800b7ffc8000", + "0x480680017fff8000", + "0x11", + "0x480680017fff8000", + "0x53656e644d657373616765546f4c31", + "0x4002800d7ffc7fff", + "0x4002800e7ffc7ffd", + "0x4002800f7ffc7ffe", + "0x400280107ffc7ff6", + "0x400280117ffc7ff7", + "0x480280137ffc8000", + "0x20680017fff7fff", + "0x36", + "0x480280127ffc8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1275130f95dda36bcbb6e9d28796c1d7e10b6e9fd5ed083e0ede4b12f613528", + "0x480680017fff8000", + "0x11", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280147ffc7fff", + "0x400280157ffc7ffb", + "0x400280167ffc7ffc", + "0x400280177ffc7ffd", + "0x400280187ffc7ffe", + "0x4802801a7ffc8000", + "0x20680017fff7fff", + "0x1a", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x46a6158a16a947e5916b2a2ca68501a45e93d7110e81aa2d6438b1c57c879a3", + "0x400080007ffe7fff", + "0x480680017fff8000", + "0x0", + "0x400080017ffd7fff", + "0x480680017fff8000", + "0x746573745f7265766572745f68656c706572", + "0x400080027ffc7fff", + "0x480680017fff8000", + "0x12", + "0x400080037ffb7fff", + "0x480a7ffa7fff8000", + "0x480280197ffc8000", + "0x482680017ffc8000", + "0x1b", + "0x480680017fff8000", + "0x1", + "0x48127ff77fff8000", + "0x482480017ff68000", + "0x4", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x5", + "0x480a7ffa7fff8000", + "0x480280197ffc8000", + "0x482680017ffc8000", + "0x1d", + "0x480680017fff8000", + "0x1", + "0x4802801b7ffc8000", + "0x4802801c7ffc8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xb", + "0x480a7ffa7fff8000", + "0x480280127ffc8000", + "0x482680017ffc8000", + "0x16", + "0x480680017fff8000", + "0x1", + "0x480280147ffc8000", + "0x480280157ffc8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xf", + "0x480a7ffa7fff8000", + "0x4802800b7ffc8000", + "0x482680017ffc8000", + "0xf", + "0x480680017fff8000", + "0x1", + "0x4802800d7ffc8000", + "0x4802800e7ffc8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x12", + "0x480a7ffa7fff8000", + "0x480280067ffc8000", + "0x482680017ffc8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ffc8000", + "0x480280097ffc8000", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ff68000", + "0xffffffffffffffffffffffffffffcb80", + "0x400280007ff57fff", + "0x10780017fff7fff", + "0x56", + "0x4825800180007ff6", + "0x3480", + "0x400280007ff57fff", + "0x482680017ff58000", + "0x1", + "0x48297ffb80007ff8", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x43", + "0x480680017fff8000", + "0x456d69744576656e74", + "0x400280007ff77fff", + "0x400280017ff77ffc", + "0x400380027ff77ffc", + "0x400380037ff77ffd", + "0x400380047ff77ff9", + "0x400380057ff77ffa", + "0x480280077ff78000", + "0x20680017fff7fff", + "0x2f", + "0x480680017fff8000", + "0x1", + "0x480280067ff78000", + "0x482680017ff78000", + "0x8", + "0xa0680017fff8000", + "0x8", + "0x48327ffc7ff88000", + "0x4824800180007fff", + "0x10000000000000000", + "0x400080007ff67fff", + "0x10780017fff7fff", + "0x13", + "0x48327ffc7ff88001", + "0x4824800180007fff", + "0xffffffffffffffff0000000000000000", + "0x400080007ff67ffe", + "0x482480017ff68000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffc7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffca", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7536345f616464204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017ff48000", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ffc7fff8000", + "0x480280067ff78000", + "0x482680017ff78000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ff78000", + "0x480280097ff78000", + "0x208b7fff7fff7ffe", + "0x48127ffe7fff8000", + "0x48127ffc7fff8000", + "0x480a7ff77fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480a7ff87fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff58000", + "0x1", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xac", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x12", + "0x4824800180007ffe", + "0x10000000000000000", + "0x4844800180008002", + "0x8000000000000110000000000000000", + "0x4830800080017ffe", + "0x480280007ffb7fff", + "0x482480017ffe8000", + "0xefffffffffffffdeffffffffffffffff", + "0x480280017ffb7fff", + "0x400280027ffb7ffb", + "0x402480017fff7ffb", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7fff", + "0x95", + "0x402780017fff7fff", + "0x1", + "0x400280007ffb7ffe", + "0x482480017ffe8000", + "0xffffffffffffffff0000000000000000", + "0x400280017ffb7fff", + "0x482680017ffb8000", + "0x2", + "0x48307ff880007ff9", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff78000", + "0x1", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff47fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x6a", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x12", + "0x4824800180007ffe", + "0x10000000000000000", + "0x4844800180008002", + "0x8000000000000110000000000000000", + "0x4830800080017ffe", + "0x480080007ff57fff", + "0x482480017ffe8000", + "0xefffffffffffffdeffffffffffffffff", + "0x480080017ff37fff", + "0x400080027ff27ffb", + "0x402480017fff7ffb", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7fff", + "0x53", + "0x402780017fff7fff", + "0x1", + "0x400080007ff87ffe", + "0x482480017ffe8000", + "0xffffffffffffffff0000000000000000", + "0x400080017ff77fff", + "0x482480017ff78000", + "0x2", + "0x48307ff880007ff9", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff78000", + "0x1", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff48000", + "0x10780017fff7fff", + "0x8", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x28", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff67ffc", + "0x480080017ff57ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027ff47ffd", + "0x10780017fff7fff", + "0x16", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff77ffd", + "0x480080017ff67ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027ff57ffe", + "0x40780017fff7fff", + "0x1", + "0x482480017ff48000", + "0x3", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x48127fe47fff8000", + "0x48127fec7fff8000", + "0x48127ff37fff8000", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x7", + "0x482480017feb8000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0xf", + "0x48127feb7fff8000", + "0x48127fec7fff8000", + "0x48127fec7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x10", + "0x482680017ffb8000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x18", + "0x480a7ffb7fff8000", + "0x48127fe37fff8000", + "0x48127fe37fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x8", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x475", + "0x40137fff7fff8003", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x432", + "0x40137fff7fff8002", + "0xa0680017fff8004", + "0xe", + "0x4825800180048002", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480280007ffa7ffc", + "0x480280017ffa7ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400280027ffa7ffd", + "0x10780017fff7fff", + "0x41f", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48317fff80008002", + "0x480280007ffa7ffd", + "0x480280017ffa7ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400280027ffa7ffe", + "0x482680017ffa8000", + "0x3", + "0x48307ff680007ff7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff58000", + "0x1", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff27fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x3d3", + "0x400180007fff8000", + "0xa0680017fff8000", + "0x16", + "0x480080007ff98003", + "0x480080017ff88003", + "0x4844800180017ffe", + "0x100000000000000000000000000000000", + "0x483180017ffd8000", + "0x482480017fff7ffd", + "0x800000000000010fffffffffffffffff7ffffffffffffef0000000000000001", + "0x20680017fff7ffc", + "0x6", + "0x402480017fff7ffd", + "0xffffffffffffffffffffffffffffffff", + "0x10780017fff7fff", + "0x4", + "0x402480017ffe7ffd", + "0xf7ffffffffffffef0000000000000000", + "0x400080027ff47ffd", + "0x20680017fff7ffe", + "0x3ba", + "0x402780017fff7fff", + "0x1", + "0x400180007ff98000", + "0x482480017ff98000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x1104800180018000", + "0x13e9", + "0x20680017fff7ffa", + "0x384", + "0x20680017fff7ffd", + "0x357", + "0x40137ffe7fff8005", + "0x40137fff7fff8006", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffa8000", + "0x1", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff78000", + "0x10780017fff7fff", + "0x8", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x315", + "0x40137fff7fff8007", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x2d4", + "0x40137fff7fff8004", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x293", + "0x40137fff7fff8001", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x52", + "0x40780017fff7fff", + "0x1", + "0x48127fe47fff8000", + "0x480a7ffb7fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x480080007ff88000", + "0x1104800180018000", + "0x143a", + "0x20680017fff7ffa", + "0x1a", + "0x20680017fff7ffd", + "0xc", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x43", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x37", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127fe97fff8000", + "0x48127fe97fff8000", + "0x208b7fff7fff7ffe", + "0x48127fe57fff8000", + "0x480a7ffb7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0x1f6", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffa8000", + "0x1", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff77fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x1b4", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x16", + "0x480080007ff28003", + "0x480080017ff18003", + "0x4844800180017ffe", + "0x100000000000000000000000000000000", + "0x483080017ffd7ffb", + "0x482480017fff7ffd", + "0x800000000000010fffffffffffffffff7ffffffffffffef0000000000000001", + "0x20680017fff7ffc", + "0x6", + "0x402480017fff7ffd", + "0xffffffffffffffffffffffffffffffff", + "0x10780017fff7fff", + "0x4", + "0x402480017ffe7ffd", + "0xf7ffffffffffffef0000000000000000", + "0x400080027fed7ffd", + "0x20680017fff7ffe", + "0x19b", + "0x402780017fff7fff", + "0x1", + "0x400080007ff27ffe", + "0x482480017ff28000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x1104800180018000", + "0x12fd", + "0x20680017fff7ffa", + "0x165", + "0x20680017fff7ffd", + "0x138", + "0x48307ffb80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffa8000", + "0x1", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff77fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xf6", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x12", + "0x4824800180007ffe", + "0x100000000", + "0x4844800180008002", + "0x8000000000000110000000000000000", + "0x4830800080017ffe", + "0x480080007fef7fff", + "0x482480017ffe8000", + "0xefffffffffffffde00000000ffffffff", + "0x480080017fed7fff", + "0x400080027fec7ffb", + "0x402480017fff7ffb", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7fff", + "0xe1", + "0x402780017fff7fff", + "0x1", + "0x400080007ff27ffe", + "0x482480017ffe8000", + "0xffffffffffffffffffffffff00000000", + "0x400080017ff17fff", + "0x482480017ff18000", + "0x2", + "0x48307ff880007ff9", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff78000", + "0x1", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff47fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x97", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x12", + "0x4824800180007ffe", + "0x100000000", + "0x4844800180008002", + "0x8000000000000110000000000000000", + "0x4830800080017ffe", + "0x480080007ff57fff", + "0x482480017ffe8000", + "0xefffffffffffffde00000000ffffffff", + "0x480080017ff37fff", + "0x400080027ff27ffb", + "0x402480017fff7ffb", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7fff", + "0x82", + "0x402780017fff7fff", + "0x1", + "0x400080007ff87ffe", + "0x482480017ffe8000", + "0xffffffffffffffffffffffff00000000", + "0x400080017ff77fff", + "0x482480017ff78000", + "0x2", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x1104800180018000", + "0x1299", + "0x20680017fff7ffa", + "0x49", + "0x20680017fff7ffd", + "0x1c", + "0x48127ff97fff8000", + "0x48127f977fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x480a80037fff8000", + "0x480a80027fff8000", + "0x480a80007fff8000", + "0x480a80057fff8000", + "0x480a80067fff8000", + "0x480a80077fff8000", + "0x480a80047fff8000", + "0x480a80017fff8000", + "0x48127f8e7fff8000", + "0x48127f8e7fff8000", + "0x48127f937fff8000", + "0x48127fb77fff8000", + "0x48127fb77fff8000", + "0x48127fbc7fff8000", + "0x48127fc47fff8000", + "0x48127fe97fff8000", + "0x48127fe97fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x48127f977fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x48127f977fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127fe97fff8000", + "0x48127fe97fff8000", + "0x208b7fff7fff7ffe", + "0x482480017ff28000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x8", + "0x48127ff27fff8000", + "0x48127fb77fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x482480017fec8000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x8", + "0x48127fec7fff8000", + "0x48127fc07fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x48127fcd7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x48127fcd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127fe97fff8000", + "0x48127fe97fff8000", + "0x208b7fff7fff7ffe", + "0x482480017fed8000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x7", + "0x48127fed7fff8000", + "0x48127fed7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff27fff8000", + "0x48127ff27fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127fea7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127fef7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127ff47fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127fe97fff8000", + "0x48127fe97fff8000", + "0x208b7fff7fff7ffe", + "0x482480017ff48000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff37fff8000", + "0x48127ff37fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x482680017ffa8000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x6", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff37fff8000", + "0x48127ff37fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x15", + "0x480680017fff8000", + "0x476574457865637574696f6e496e666f", + "0x400280007fe67fff", + "0x400380017fe67fe5", + "0x480280037fe68000", + "0x20680017fff7fff", + "0x160", + "0x480280047fe68000", + "0x480080007fff8000", + "0x480080007fff8000", + "0x480080017ffe8000", + "0x480080027ffd8000", + "0x480280027fe68000", + "0x402780017fe68001", + "0x5", + "0x480080017ffa8000", + "0x400180027ff98000", + "0x400180037ff98003", + "0x400180047ff98002", + "0x48287fe780007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x2", + "0x10780017fff7fff", + "0x9", + "0x48287fe880007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x1", + "0x10780017fff7fff", + "0x134", + "0x48287fe980007ffb", + "0x20680017fff7fff", + "0x131", + "0x400180007ffc8004", + "0x400180017ffc8005", + "0x400180027ffc8006", + "0x400180037ffc8007", + "0x400180047ffc8008", + "0x400180057ffc8009", + "0x400180067ffc800a", + "0x400180077ffc800b", + "0x400180087ffc800c", + "0x400180097ffc800d", + "0x4001800a7ffc800e", + "0x4001800b7ffc800f", + "0x4001800c7ffc8010", + "0x4001800d7ffc8011", + "0x4001800e7ffc8012", + "0x4001800f7ffc8013", + "0x400180107ffc8014", + "0x48297fea80008004", + "0x20680017fff7fff", + "0x10b", + "0x48297feb80008005", + "0x20680017fff7fff", + "0x104", + "0x48297fec80008006", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x103", + "0x4829800780008008", + "0x48297fed80007fee", + "0x48307fff80007ffe", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x480a7fe47fff8000", + "0x48127ff47fff8000", + "0x10780017fff7fff", + "0x10", + "0x480a7fe47fff8000", + "0x48127ff47fff8000", + "0x480a80077fff8000", + "0x480a80087fff8000", + "0x480a7fed7fff8000", + "0x480a7fee7fff8000", + "0x1104800180018000", + "0x105b", + "0x20680017fff7ffa", + "0xdc", + "0x20680017fff7fff", + "0x6", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0xea", + "0x48297fef80008009", + "0x20680017fff7fff", + "0xcf", + "0x48297ff08000800a", + "0x20680017fff7fff", + "0xc8", + "0x48297ff18000800b", + "0x20680017fff7fff", + "0xc1", + "0x4829800c8000800d", + "0x48297ff280007ff3", + "0x4844800180007ffe", + "0x3", + "0x4844800180007ffe", + "0x3", + "0x48307fff80007ffe", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x48127ff07fff8000", + "0x48127ff07fff8000", + "0x10780017fff7fff", + "0x10", + "0x48127ff07fff8000", + "0x48127ff07fff8000", + "0x480a800c7fff8000", + "0x480a800d7fff8000", + "0x480a7ff27fff8000", + "0x480a7ff37fff8000", + "0x1104800180018000", + "0x10b4", + "0x20680017fff7ffa", + "0xa2", + "0x20680017fff7fff", + "0x6", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0xc2", + "0x48297ff48000800e", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x10780017fff7fff", + "0xb9", + "0x4829800f80008010", + "0x48297ff580007ff6", + "0x48307fff80007ffe", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x10780017fff7fff", + "0x10", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x480a800f7fff8000", + "0x480a80107fff8000", + "0x480a7ff57fff8000", + "0x480a7ff67fff8000", + "0x1104800180018000", + "0x100f", + "0x20680017fff7ffa", + "0x78", + "0x20680017fff7fff", + "0x6", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x9e", + "0x48297ff780008011", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x10780017fff7fff", + "0x95", + "0x48297ff880008012", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x10780017fff7fff", + "0x8c", + "0x4829801380008014", + "0x48297ff980007ffa", + "0x48307fff80007ffe", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x48127ff37fff8000", + "0x48127ff37fff8000", + "0x10780017fff7fff", + "0x81", + "0x48127ff37fff8000", + "0x48127ff37fff8000", + "0x480a80137fff8000", + "0x480a80147fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x1104800180018000", + "0xfe2", + "0x20680017fff7ffa", + "0x45", + "0x20680017fff7fff", + "0x6", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x71", + "0x48297ffb80008000", + "0x20680017fff7fff", + "0x2e", + "0x48297ffc80008003", + "0x20680017fff7fff", + "0x1d", + "0x48297ffd80008002", + "0x20680017fff7fff", + "0xc", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480a80017fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x53454c4543544f525f4d49534d41544348", + "0x400080007ffe7fff", + "0x48127ff37fff8000", + "0x48127ff37fff8000", + "0x480a80017fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x434f4e54524143545f4d49534d41544348", + "0x400080007ffe7fff", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x480a80017fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x43414c4c45525f4d49534d41544348", + "0x400080007ffe7fff", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480a80017fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x10780017fff7fff", + "0x1e", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x10780017fff7fff", + "0x18", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x10780017fff7fff", + "0x12", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x10780017fff7fff", + "0x1e", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x10780017fff7fff", + "0x1a", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x10780017fff7fff", + "0x16", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480a80017fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x10780017fff7fff", + "0x4", + "0x40780017fff7fff", + "0x2", + "0x480a7fe47fff8000", + "0x48127ff77fff8000", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x54585f494e464f5f4d49534d41544348", + "0x400080007ffe7fff", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480a80017fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x424c4f434b5f494e464f5f4d49534d41544348", + "0x400080007ffe7fff", + "0x480a7fe47fff8000", + "0x48127ff87fff8000", + "0x480a80017fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480a7fe47fff8000", + "0x480280027fe68000", + "0x482680017fe68000", + "0x6", + "0x480680017fff8000", + "0x1", + "0x480280047fe68000", + "0x480280057fe68000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x400180007fff7ff9", + "0x400180017fff7ffb", + "0x480680017fff8000", + "0x2", + "0x400080027ffe7fff", + "0x482680017ffc8000", + "0x1", + "0x400080037ffd7fff", + "0x482680017ffd8000", + "0x1", + "0x400080047ffc7fff", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x5", + "0x480680017fff8000", + "0x4c69627261727943616c6c", + "0x400280007ff87fff", + "0x400380017ff87ff7", + "0x400380027ff87ff9", + "0x400380037ff87ffa", + "0x400280047ff87ffd", + "0x400280057ff87ffe", + "0x480280077ff88000", + "0x20680017fff7fff", + "0x25", + "0x40780017fff7fff", + "0x1", + "0x400180007fff7ffc", + "0x400180017fff7ffd", + "0x480280067ff88000", + "0x48127ffe7fff8000", + "0x482480017ffd8000", + "0x2", + "0x480680017fff8000", + "0x4c69627261727943616c6c", + "0x4002800a7ff87fff", + "0x4002800b7ff87ffc", + "0x4003800c7ff87ff9", + "0x4003800d7ff87ffb", + "0x4002800e7ff87ffd", + "0x4002800f7ff87ffe", + "0x480280117ff88000", + "0x20680017fff7fff", + "0xa", + "0x480280107ff88000", + "0x482680017ff88000", + "0x14", + "0x480680017fff8000", + "0x0", + "0x480280127ff88000", + "0x480280137ff88000", + "0x208b7fff7fff7ffe", + "0x480280107ff88000", + "0x482680017ff88000", + "0x14", + "0x480680017fff8000", + "0x1", + "0x480280127ff88000", + "0x480280137ff88000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x6", + "0x480280067ff88000", + "0x482680017ff88000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ff88000", + "0x480280097ff88000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x4", + "0x10780017fff7fff", + "0xb2", + "0x48037ffd7ffc8002", + "0x48037ffe7ffc8003", + "0x48037fff7ffc8004", + "0x480380007ffa8000", + "0x4825800180018003", + "0x1", + "0x4828800080018000", + "0x480280017ffa8000", + "0x4846800180008000", + "0x3", + "0x48327fff80028000", + "0x400180027fff8004", + "0x400180017fff7ffd", + "0x400380007ffc8002", + "0x400380017ffc8003", + "0x4826800180048000", + "0x1", + "0x400280027ffc7fff", + "0x482680017ffa8000", + "0x2", + "0x480080007ffd8000", + "0x480a7ffd7fff8000", + "0x40337ffe80017ffd", + "0x1104800180018000", + "0xf", + "0x48307fff80007ffe", + "0x48317fff80008001", + "0x4844800180007fff", + "0x3", + "0x484480017fff8000", + "0xfd2", + "0x48127ff97fff8000", + "0x48327ffe7ffb8000", + "0x482680017ffc8000", + "0x3", + "0x48127ff87fff8000", + "0x48127ff67fff8000", + "0x208b7fff7fff7ffe", + "0x482b7ffc80007ffd", + "0x40780017fff7fff", + "0x3", + "0x20780017fff8000", + "0x6", + "0x480a7ffb7fff8000", + "0x480a80037fff8000", + "0x480a80037fff8000", + "0x208b7fff7fff7ffe", + "0x4845800180008000", + "0x3", + "0xa0780017fff8002", + "0x7", + "0x400380007ffb8001", + "0x402680017ffb7fff", + "0x1", + "0x10780017fff7fff", + "0x3", + "0x400a7ffb7fff7fff", + "0x480a7ffc7fff8000", + "0x4825800180007ffd", + "0x1", + "0x480a80017fff8000", + "0x48127ffb7fff8000", + "0x480a80037fff8000", + "0x480a80027fff8000", + "0x1104800180018000", + "0x4", + "0x480a80037fff8000", + "0x208b7fff7fff7ffe", + "0x480280007ff78002", + "0x4844800180018002", + "0x3", + "0x483280017ff88004", + "0x4800800280038004", + "0x482680017ff78004", + "0x1", + "0x4801800080017ffa", + "0x480380007ffc7ffa", + "0x480080017fff7ffd", + "0x480280017ffc7ffc", + "0x400680017fff7ffb", + "0x0", + "0x20680017fff7ffc", + "0xf", + "0x480080007fff8000", + "0x482480017fff8000", + "0x1", + "0x484480017fff8000", + "0x3", + "0x48307fff7ffa8001", + "0x4800800180007ffa", + "0x480080027fff8000", + "0x480180007ffe7ffa", + "0x402480017ff87fff", + "0x1", + "0x20680017fff7ffc", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff6", + "0x48317ffd80007ff9", + "0x400080007ffe7fff", + "0x48287ff780007ffe", + "0x400280027ffc7ffc", + "0x40337fff80017ffb", + "0x20780017fff8001", + "0x7", + "0x482480017ffd8000", + "0x1", + "0x482680017ffc8000", + "0x3", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0xe", + "0x482680017ffa8000", + "0x1", + "0x48317fff80008000", + "0x400080017ffb7fff", + "0x482480017ffb8000", + "0x2", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a80007fff8000", + "0x480a80017fff8000", + "0x10780017fff7fff", + "0x32", + "0x4829800080007ffa", + "0x20680017fff7fff", + "0x4", + "0x402780017fff7fff", + "0x1", + "0x480080017ffc8000", + "0x480080027ffb8000", + "0x484480017fff8000", + "0x2aaaaaaaaaaaab05555555555555556", + "0x48307fff7ffd8000", + "0x480080037ff88000", + "0x480080047ff78000", + "0x484480017fff8000", + "0x4000000000000088000000000000001", + "0x48307fff7ffd8000", + "0x48307fff7ffb8000", + "0x48507ffe7ffa8000", + "0xa0680017fff8000", + "0xc", + "0x484680017ffa8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x402480017fff7ffc", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x4829800080007ffa", + "0x4826800180008000", + "0x1", + "0x40507fff7ffe7ffb", + "0x10780017fff7fff", + "0xf", + "0xa0680017fff8000", + "0xa", + "0x4846800180008000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x482480017fff8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x40327fff7ffa7ffa", + "0x40527fff7ffa7ffb", + "0x10780017fff7fff", + "0x5", + "0x480a80007fff7ffc", + "0x48297ffa80008000", + "0x40527fff7ffa7ffb", + "0x482480017fee8000", + "0x5", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a80007fff8000", + "0x480a80017fff8000", + "0x482680017ffc8000", + "0x3", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff98", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x48127ffa7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x400080007ffd7ffe", + "0x400080017ffd7fff", + "0x40780017fff7fff", + "0x1", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x2", + "0x48127ffb7fff8000", + "0x48127ffa7fff8000", + "0x1104800180018000", + "0xf45", + "0x20680017fff7ffb", + "0xb4", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x1104800180018000", + "0xf92", + "0x20680017fff7ffd", + "0xa1", + "0x480680017fff8000", + "0x4b656363616b", + "0x400280007ffd7fff", + "0x400280017ffd7ffb", + "0x400280027ffd7ffd", + "0x400280037ffd7ffe", + "0x480280057ffd8000", + "0x20680017fff7fff", + "0x90", + "0x480280067ffd8000", + "0x480280047ffd8000", + "0x482680017ffd8000", + "0x8", + "0x480280077ffd8000", + "0x4824800180007ffc", + "0x587f7cc3722e9654ea3963d5fe8c0748", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x57726f6e6720686173682076616c7565", + "0x400080007ffe7fff", + "0x48127ff27fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x4824800180007ffe", + "0xa5963aa610cb75ba273817bce5f8c48f", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x57726f6e6720686173682076616c7565", + "0x400080007ffe7fff", + "0x48127ff17fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x1", + "0x400080007ffe7fff", + "0x48127ffe7fff8000", + "0x482480017ffd8000", + "0x1", + "0x480680017fff8000", + "0x4b656363616b", + "0x400080007ff77fff", + "0x400080017ff77ff6", + "0x400080027ff77ffd", + "0x400080037ff77ffe", + "0x480080057ff78000", + "0x20680017fff7fff", + "0x11", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x53686f756c64206661696c", + "0x400080007ffe7fff", + "0x48127feb7fff8000", + "0x480080047ff38000", + "0x482480017ff28000", + "0x8", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480080067ff68000", + "0x480080077ff58000", + "0x480680017fff8000", + "0x0", + "0x480080047ff38000", + "0x482480017ff28000", + "0x8", + "0x48307ffb80007ffc", + "0xa0680017fff8000", + "0x6", + "0x48307ffe80007ffb", + "0x400080007fe57fff", + "0x10780017fff7fff", + "0x26", + "0x482480017ffb8000", + "0x1", + "0x48307fff80007ffd", + "0x400080007fe47fff", + "0x48307ff97ff78000", + "0x480080007fff8000", + "0x4824800180007fff", + "0x496e76616c696420696e707574206c656e677468", + "0x482480017fe18000", + "0x1", + "0x20680017fff7ffe", + "0xc", + "0x48127fff7fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x57726f6e67206572726f72206d7367", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127ff37fff8000", + "0x48127ff37fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e646578206f7574206f6620626f756e6473", + "0x400080007ffe7fff", + "0x482480017fe38000", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x480280047ffd8000", + "0x482680017ffd8000", + "0x8", + "0x480280067ffd8000", + "0x480280077ffd8000", + "0x10780017fff7fff", + "0xe", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a7ffd7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x10780017fff7fff", + "0x7", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffd7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x61616161", + "0x400080007ffe7fff", + "0x480a7ffb7fff8000", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x1104800180018000", + "0xfcb", + "0x20680017fff7ffd", + "0x37", + "0x1104800180018000", + "0x2401", + "0x482480017fff8000", + "0x2400", + "0x48127ff97fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ffa7fff8000", + "0x1104800180018000", + "0x10bf", + "0x20680017fff7ffc", + "0x22", + "0x48127fff7fff8000", + "0x480080007fff8000", + "0x4824800180007fff", + "0x61be55a8", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x57726f6e6720686173682076616c7565", + "0x400080007ffe7fff", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x10780017fff7fff", + "0x7", + "0x48127ffc7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x536563703235366b314e6577", + "0x400280007ffd7fff", + "0x400380017ffd7ffb", + "0x400280027ffd7ffb", + "0x400280037ffd7ffc", + "0x400280047ffd7ffd", + "0x400280057ffd7ffe", + "0x480280077ffd8000", + "0x20680017fff7fff", + "0x145", + "0x480280087ffd8000", + "0x480280097ffd8000", + "0x480280067ffd8000", + "0x482680017ffd8000", + "0xa", + "0x20680017fff7ffc", + "0x11", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x53686f756c64206265206e6f6e65", + "0x400080007ffe7fff", + "0x480a7ffa7fff8000", + "0x48127ffb7fff8000", + "0x480a7ffc7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0xfffffffffffffffffffffffefffffc2f", + "0x480680017fff8000", + "0xffffffffffffffffffffffffffffffff", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x536563703235366b314e6577", + "0x400080007ffa7fff", + "0x400080017ffa7ff9", + "0x400080027ffa7ffb", + "0x400080037ffa7ffc", + "0x400080047ffa7ffd", + "0x400080057ffa7ffe", + "0x480080077ffa8000", + "0x20680017fff7fff", + "0x12", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x53686f756c64206661696c", + "0x400080007ffe7fff", + "0x480a7ffa7fff8000", + "0x480080067ff68000", + "0x480a7ffc7fff8000", + "0x482480017ff48000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480080087ff98000", + "0x480080097ff88000", + "0x480680017fff8000", + "0x0", + "0x480080067ff68000", + "0x482480017ff58000", + "0xa", + "0x48307ffb80007ffc", + "0xa0680017fff8000", + "0x6", + "0x48307ffe80007ffb", + "0x400280007ffa7fff", + "0x10780017fff7fff", + "0xee", + "0x482480017ffb8000", + "0x1", + "0x48307fff80007ffd", + "0x400280007ffa7fff", + "0x48307ff97ff78000", + "0x480080007fff8000", + "0x4824800180007fff", + "0x496e76616c696420617267756d656e74", + "0x482680017ffa8000", + "0x1", + "0x20680017fff7ffe", + "0xd3", + "0x480680017fff8000", + "0xe3e70682c2094cac629f6fbed82c07cd", + "0x480680017fff8000", + "0xf728b4fa42485e3a0a5d2f346baa9455", + "0x480680017fff8000", + "0x8e031ab54fc0c4a8f0dc94fad0d0611", + "0x480680017fff8000", + "0x8e182ca967f38e1bd6a49583f43f1876", + "0x480680017fff8000", + "0x536563703235366b314e6577", + "0x400080007ff27fff", + "0x400080017ff27ff1", + "0x400080027ff27ffb", + "0x400080037ff27ffc", + "0x400080047ff27ffd", + "0x400080057ff27ffe", + "0x480080077ff28000", + "0x20680017fff7fff", + "0xb6", + "0x480080087ff18000", + "0x480080097ff08000", + "0x480080067fef8000", + "0x482480017fee8000", + "0xa", + "0x20680017fff7ffc", + "0xa0", + "0x480680017fff8000", + "0x536563703235366b314765745879", + "0x400080007ffe7fff", + "0x400080017ffe7ffd", + "0x400080027ffe7ffc", + "0x480080047ffe8000", + "0x20680017fff7fff", + "0x8e", + "0x480080057ffd8000", + "0x480080067ffc8000", + "0x480080037ffb8000", + "0x482480017ffa8000", + "0x9", + "0x480080077ff98000", + "0x480080087ff88000", + "0x4824800180007ffa", + "0xe3e70682c2094cac629f6fbed82c07cd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x3", + "0x10780017fff7fff", + "0xa", + "0x4824800180007ffa", + "0xf728b4fa42485e3a0a5d2f346baa9455", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x2", + "0x10780017fff7fff", + "0x12", + "0x4824800180007ffc", + "0x8e031ab54fc0c4a8f0dc94fad0d0611", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x1", + "0x10780017fff7fff", + "0x8", + "0x4824800180007ffc", + "0x8e182ca967f38e1bd6a49583f43f1876", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x11", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x556e657870656374656420636f6f7264696e61746573", + "0x400080007ffe7fff", + "0x48127fe77fff8000", + "0x48127ff57fff8000", + "0x480a7ffc7fff8000", + "0x48127ff47fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x767410c1", + "0x480680017fff8000", + "0x100000000", + "0x480080007fe78005", + "0x480080017fe68005", + "0x4824800180047ffe", + "0x1", + "0x48307ffd7ffe7ffc", + "0x480080027fe37ffd", + "0xa0680017fff7ffd", + "0x6", + "0x482480017ff97ffd", + "0xffffffffffffffff0000000000000000", + "0x10780017fff7fff", + "0x4", + "0x482480017fff7ffd", + "0xffffffffffffffff0000000000000000", + "0x400080037fe07ffc", + "0x40507ffe7ff87ffd", + "0x40307fff7ffd7ff7", + "0x484480017fff8000", + "0x100000000000000000000000000000000", + "0x482480017fdf8000", + "0x4", + "0x48127fed7fff8000", + "0x480a7ffc7fff8000", + "0x48127fec7fff8000", + "0x480680017fff8000", + "0x788f195a6f509ca3e934f78d7a71dd85", + "0x480680017fff8000", + "0xe888fbb4cf9ae6254f19ba12e6d9af54", + "0x480680017fff8000", + "0x7a5f81cf3ee10044320a0d03b62d3e9a", + "0x480680017fff8000", + "0x4c8e4fbc1fbb1dece52185e532812c4f", + "0x480680017fff8000", + "0xc2b7f60e6a8b84965830658f08f7410c", + "0x480680017fff8000", + "0x4ac5e5c0c0e8a4871583cc131f35fb49", + "0x480680017fff8000", + "0x1", + "0x482480017ff48000", + "0xbb448978bd42b984d7de5970bcaf5c43", + "0x1104800180018000", + "0xffa", + "0x20680017fff7ffd", + "0x17", + "0x20680017fff7ffe", + "0xd", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x400080007fff7ffe", + "0x48127fff7fff8000", + "0x482480017ffe8000", + "0x1", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x1", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x48127ff37fff8000", + "0x480080037ffc8000", + "0x480a7ffc7fff8000", + "0x482480017ffa8000", + "0x7", + "0x480680017fff8000", + "0x1", + "0x480080057ff88000", + "0x480080067ff78000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127ff37fff8000", + "0x48127ffb7fff8000", + "0x480a7ffc7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x480080067ff08000", + "0x480a7ffc7fff8000", + "0x482480017fee8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480080087fec8000", + "0x480080097feb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x57726f6e67206572726f72206d7367", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127ff37fff8000", + "0x480a7ffc7fff8000", + "0x48127ff27fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e646578206f7574206f6620626f756e6473", + "0x400080007ffe7fff", + "0x482680017ffa8000", + "0x1", + "0x48127ff87fff8000", + "0x480a7ffc7fff8000", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480280067ffd8000", + "0x480a7ffc7fff8000", + "0x482680017ffd8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ffd8000", + "0x480280097ffd8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x5365637032353672314e6577", + "0x400280007ffd7fff", + "0x400380017ffd7ffc", + "0x400280027ffd7ffb", + "0x400280037ffd7ffc", + "0x400280047ffd7ffd", + "0x400280057ffd7ffe", + "0x480280077ffd8000", + "0x20680017fff7fff", + "0x16d", + "0x480280087ffd8000", + "0x480280097ffd8000", + "0x480280067ffd8000", + "0x482680017ffd8000", + "0xa", + "0x20680017fff7ffc", + "0x12", + "0x40780017fff7fff", + "0x327", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x53686f756c64206265206e6f6e65", + "0x400080007ffe7fff", + "0x480a7ffb7fff8000", + "0x48127cd47fff8000", + "0x48127cd47fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0xffffffffffffffffffffffff", + "0x480680017fff8000", + "0xffffffff000000010000000000000000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x5365637032353672314e6577", + "0x400080007ffa7fff", + "0x400080017ffa7ff9", + "0x400080027ffa7ffb", + "0x400080037ffa7ffc", + "0x400080047ffa7ffd", + "0x400080057ffa7ffe", + "0x480080077ffa8000", + "0x20680017fff7fff", + "0x13", + "0x40780017fff7fff", + "0x321", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x53686f756c64206661696c", + "0x400080007ffe7fff", + "0x480a7ffb7fff8000", + "0x480080067cd58000", + "0x482480017cd48000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480080087ff98000", + "0x480080097ff88000", + "0x480680017fff8000", + "0x0", + "0x480080067ff68000", + "0x482480017ff58000", + "0xa", + "0x48307ffb80007ffc", + "0xa0680017fff8000", + "0x6", + "0x48307ffe80007ffb", + "0x400280007ffb7fff", + "0x10780017fff7fff", + "0x113", + "0x482480017ffb8000", + "0x1", + "0x48307fff80007ffd", + "0x400280007ffb7fff", + "0x48307ff97ff78000", + "0x480080007fff8000", + "0x4824800180007fff", + "0x496e76616c696420617267756d656e74", + "0x482680017ffb8000", + "0x1", + "0x20680017fff7ffe", + "0xf7", + "0x480680017fff8000", + "0x2d483fe223b12b91047d83258a958b0f", + "0x480680017fff8000", + "0x502a43ce77c6f5c736a82f847fa95f8c", + "0x480680017fff8000", + "0xce729c7704f4ddf2eaaf0b76209fe1b0", + "0x480680017fff8000", + "0xdb0a2e6710c71ba80afeb3abdf69d306", + "0x480680017fff8000", + "0x5365637032353672314e6577", + "0x400080007ff27fff", + "0x400080017ff27ff1", + "0x400080027ff27ffb", + "0x400080037ff27ffc", + "0x400080047ff27ffd", + "0x400080057ff27ffe", + "0x480080077ff28000", + "0x20680017fff7fff", + "0xd9", + "0x480080087ff18000", + "0x480080097ff08000", + "0x480080067fef8000", + "0x482480017fee8000", + "0xa", + "0x20680017fff7ffc", + "0xc2", + "0x480680017fff8000", + "0x5365637032353672314765745879", + "0x400080007ffe7fff", + "0x400080017ffe7ffd", + "0x400080027ffe7ffc", + "0x480080047ffe8000", + "0x20680017fff7fff", + "0xaf", + "0x480080057ffd8000", + "0x480080067ffc8000", + "0x480080037ffb8000", + "0x482480017ffa8000", + "0x9", + "0x480080077ff98000", + "0x480080087ff88000", + "0x4824800180007ffa", + "0x2d483fe223b12b91047d83258a958b0f", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x301", + "0x10780017fff7fff", + "0xa", + "0x4824800180007ffa", + "0x502a43ce77c6f5c736a82f847fa95f8c", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x300", + "0x10780017fff7fff", + "0x14", + "0x4824800180007ffc", + "0xce729c7704f4ddf2eaaf0b76209fe1b0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x2ff", + "0x10780017fff7fff", + "0xa", + "0x4824800180007ffc", + "0xdb0a2e6710c71ba80afeb3abdf69d306", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x12", + "0x40780017fff7fff", + "0x2fe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x556e657870656374656420636f6f7264696e61746573", + "0x400080007ffe7fff", + "0x48127ce97fff8000", + "0x48127cf77fff8000", + "0x48127cf77fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x49288242", + "0x480680017fff8000", + "0x100000000", + "0x480080007fe78005", + "0x480080017fe68005", + "0x4824800180047ffe", + "0x1", + "0x48307ffd7ffe7ffc", + "0x480080027fe37ffd", + "0xa0680017fff7ffd", + "0x6", + "0x482480017ff97ffd", + "0xffffffffffffffff0000000000000000", + "0x10780017fff7fff", + "0x4", + "0x482480017fff7ffd", + "0xffffffffffffffff0000000000000000", + "0x400080037fe07ffc", + "0x40507ffe7ff87ffd", + "0x40307fff7ffd7ff7", + "0x480680017fff8000", + "0x32e41495a944d0045b522eba7240fad5", + "0x480680017fff8000", + "0x4aaec73635726f213fb8a9e64da3b86", + "0x480680017fff8000", + "0xaaf7b4e09fc81d6d1aa546e8365d525d", + "0x480680017fff8000", + "0x87d9315798aaa3a5ba01775787ced05e", + "0x482480017fdc8000", + "0x4", + "0x480680017fff8000", + "0x5365637032353672314e6577", + "0x400080007fea7fff", + "0x400080017fea7fe9", + "0x400080027fea7ffa", + "0x400080037fea7ffb", + "0x400080047fea7ffc", + "0x400080057fea7ffd", + "0x480080077fea8000", + "0x20680017fff7fff", + "0x3f", + "0x480080087fe98000", + "0x480080097fe88000", + "0x480080067fe78000", + "0x482480017fe68000", + "0xa", + "0x20680017fff7ffc", + "0x28", + "0x48127ff97fff8000", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x27ae41e4649b934ca495991b7852b855", + "0x480680017fff8000", + "0xe3b0c44298fc1c149afbf4c8996fb924", + "0x480680017fff8000", + "0x42d16e47f219f9e98e76e09d8770b34a", + "0x480680017fff8000", + "0xb292a619339f6e567a305c951c0dcbcc", + "0x480680017fff8000", + "0xe59ec2a17ce5bd2dab2abebdf89a62e2", + "0x480680017fff8000", + "0x177e60492c5a8242f76f07bfe3661bd", + "0x48127ff47fff8000", + "0x1104800180018000", + "0xf5e", + "0x20680017fff7ffd", + "0xc", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2ea", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127d0d7fff8000", + "0x48127d117fff8000", + "0x48127d117fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2f0", + "0x48127d0d7fff8000", + "0x480080067cf88000", + "0x482480017cf78000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480080087cf58000", + "0x480080097cf48000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x30a", + "0x48127ce97fff8000", + "0x480080037cf28000", + "0x482480017cf18000", + "0x7", + "0x480680017fff8000", + "0x1", + "0x480080057cef8000", + "0x480080067cee8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x30a", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127ce97fff8000", + "0x48127cf17fff8000", + "0x48127cf17fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x310", + "0x48127ce97fff8000", + "0x480080067ce08000", + "0x482480017cdf8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480080087cdd8000", + "0x480080097cdc8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x314", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x57726f6e67206572726f72206d7367", + "0x400080007ffe7fff", + "0x48127ce97fff8000", + "0x48127cdf7fff8000", + "0x48127cdf7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x319", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e646578206f7574206f6620626f756e6473", + "0x400080007ffe7fff", + "0x482680017ffb8000", + "0x1", + "0x48127cdf7fff8000", + "0x48127cdf7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x32d", + "0x480a7ffb7fff8000", + "0x480280067ffd8000", + "0x482680017ffd8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ffd8000", + "0x480280097ffd8000", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0xffffffffffffffffffffffffffffc57c", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x13b", + "0x4825800180007ffa", + "0x3a84", + "0x400280007ff97fff", + "0x48297ffc80007ffd", + "0x480680017fff8000", + "0x3", + "0x48307fff80017ffe", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400280017ff97fff", + "0x10780017fff7fff", + "0x11e", + "0x400280017ff97fff", + "0x482680017ff98000", + "0x2", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xf8", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xd5", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff88000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xb2", + "0x20680017fff7fff", + "0x43", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ff4", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007fec7ffc", + "0x480080017feb7ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027fea7ffd", + "0x10780017fff7fff", + "0x26", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ff3", + "0x480080007fed7ffd", + "0x480080017fec7ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027feb7ffe", + "0x482480017feb8000", + "0x3", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x400280007ffb7fff", + "0x400280017ffb7fe4", + "0x400280027ffb7fee", + "0x400280037ffb7ff3", + "0x400280047ffb7ff5", + "0x400280057ffb7ff6", + "0x480280077ffb8000", + "0x20680017fff7fff", + "0x8", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x10780017fff7fff", + "0x80", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482480017fe88000", + "0x3", + "0x48127fe27fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x4824800180007fff", + "0x1", + "0x20680017fff7fff", + "0x43", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ff3", + "0x800000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8002", + "0x480080007feb7ffc", + "0x480080017fea7ffc", + "0x402480017ffb7ffd", + "0xffffffffffffffeeffffffffffffffff", + "0x400080027fe97ffd", + "0x10780017fff7fff", + "0x26", + "0x484480017fff8001", + "0x8000000000000000000000000000000", + "0x48307fff80007ff2", + "0x480080007fec7ffd", + "0x480080017feb7ffd", + "0x402480017ffc7ffe", + "0xf8000000000000000000000000000000", + "0x400080027fea7ffe", + "0x482480017fea8000", + "0x3", + "0x480680017fff8000", + "0x4c69627261727943616c6c", + "0x400280007ffb7fff", + "0x400280017ffb7fe3", + "0x400280027ffb7fed", + "0x400280037ffb7ff2", + "0x400280047ffb7ff4", + "0x400280057ffb7ff5", + "0x480280077ffb8000", + "0x20680017fff7fff", + "0x8", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x10780017fff7fff", + "0x3b", + "0x48127ffd7fff8000", + "0x480280067ffb8000", + "0x482680017ffb8000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x480280087ffb8000", + "0x480280097ffb8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482480017fe78000", + "0x3", + "0x48127fe17fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x4824800180007ff9", + "0x62c83572d28cb834a3de3c1e94977a4191469a4a8c26d1d7bc55305e640ed5", + "0x20680017fff7fff", + "0xa", + "0x48127fee7fff8000", + "0x48127fe87fff8000", + "0x480a7ffb7fff8000", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff19", + "0x208b7fff7fff7ffe", + "0x4824800180007ff8", + "0x32564d7e0fe091d49b4c20f4632191e4ed6986bf993849879abfef9465def25", + "0x20680017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x6661696c", + "0x400080007ffe7fff", + "0x48127feb7fff8000", + "0x48127fe57fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127fed7fff8000", + "0x48127fe77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127fee7fff8000", + "0x48127fe87fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127ff37fff8000", + "0x48127fed7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127ff27fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4469766973696f6e2062792030", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x2", + "0x48127ff77fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffc8000", + "0xfffffffffffffffffffffffffffffbd2", + "0x400280007ffb7fff", + "0x10780017fff7fff", + "0x1d", + "0x4825800180007ffc", + "0x42e", + "0x400280007ffb7fff", + "0x482680017ffb8000", + "0x1", + "0x20780017fff7ffd", + "0xf", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7265637572736976655f6661696c", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127fff7fff8000", + "0x48127ffd7fff8000", + "0x4825800180007ffd", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe2", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ffb8000", + "0x1", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffc8000", + "0xfffffffffffffffffffffffffffffbd2", + "0x400280007ffb7fff", + "0x10780017fff7fff", + "0x19", + "0x4825800180007ffc", + "0x42e", + "0x400280007ffb7fff", + "0x482680017ffb8000", + "0x1", + "0x20780017fff7ffd", + "0xb", + "0x48127fff7fff8000", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127fff7fff8000", + "0x48127ffd7fff8000", + "0x4825800180007ffd", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe6", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ffb8000", + "0x1", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x2691cb735b18f3f656c3b82bd97a32b65d15019b64117513f8604d1e06fe58b", + "0x400280007ff97fff", + "0x400380017ff97ffb", + "0x480280027ff98000", + "0xa0680017fff8005", + "0xe", + "0x4824800180057ffe", + "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8003", + "0x480280007ff77ffc", + "0x480280017ff77ffc", + "0x482480017ffb7ffd", + "0xffffffffffffffeefffffffffffffeff", + "0x400280027ff77ffc", + "0x10780017fff7fff", + "0x11", + "0x48127ffe7fff8005", + "0x484480017ffe8000", + "0x8000000000000000000000000000000", + "0x48307ffe7fff8003", + "0x480280007ff77ffd", + "0x482480017ffc7ffe", + "0xf0000000000000000000000000000100", + "0x480280017ff77ffd", + "0x400280027ff77ff9", + "0x402480017ffd7ff9", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7ffd", + "0x4", + "0x402780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x0", + "0x482680017ff98000", + "0x3", + "0x482680017ff78000", + "0x3", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400280007ffa7fff", + "0x400380017ffa7ff8", + "0x400280027ffa7ffc", + "0x400280037ffa7ffb", + "0x480280057ffa8000", + "0x20680017fff7fff", + "0x84", + "0x480280047ffa8000", + "0x480680017fff8000", + "0x0", + "0x482480017ff88000", + "0x1", + "0x480280067ffa8000", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400280077ffa7fff", + "0x400280087ffa7ffb", + "0x400280097ffa7ffc", + "0x4002800a7ffa7ffd", + "0x4802800c7ffa8000", + "0x20680017fff7fff", + "0x6c", + "0x480680017fff8000", + "0x2691cb735b18f3f656c3b82bd97a32b65d15019b64117513f8604d1e06fe58b", + "0x400080007ff57fff", + "0x400180017ff57ffb", + "0x480080027ff58000", + "0xa0680017fff8005", + "0xe", + "0x4824800180057ffe", + "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8003", + "0x480080007ff17ffc", + "0x480080017ff07ffc", + "0x482480017ffb7ffd", + "0xffffffffffffffeefffffffffffffeff", + "0x400080027fee7ffc", + "0x10780017fff7fff", + "0x11", + "0x48127ffe7fff8005", + "0x484480017ffe8000", + "0x8000000000000000000000000000000", + "0x48307ffe7fff8003", + "0x480080007ff17ffd", + "0x482480017ffc7ffe", + "0xf0000000000000000000000000000100", + "0x480080017fef7ffd", + "0x400080027fee7ff9", + "0x402480017ffd7ff9", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7ffd", + "0x4", + "0x402780017fff7fff", + "0x1", + "0x4802800b7ffa8000", + "0x480680017fff8000", + "0x0", + "0x48287ffc7ff28000", + "0x4802800d7ffa8000", + "0x482480017fe98000", + "0x3", + "0x482480017fe98000", + "0x3", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x4002800e7ffa7fff", + "0x4002800f7ffa7ff9", + "0x400280107ffa7ffa", + "0x400280117ffa7ff8", + "0x400280127ffa7ffb", + "0x480280147ffa8000", + "0x20680017fff7fff", + "0x27", + "0x480280137ffa8000", + "0x480680017fff8000", + "0x0", + "0x482480017ff58000", + "0x1", + "0x48287ffd7ff88000", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280157ffa7fff", + "0x400280167ffa7ffb", + "0x400280177ffa7ffc", + "0x400280187ffa7ffd", + "0x400280197ffa7ffe", + "0x4802801b7ffa8000", + "0x20680017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x4", + "0x48127ff37fff8000", + "0x4802801a7ffa8000", + "0x48127ff07fff8000", + "0x482680017ffa8000", + "0x1c", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x4802801a7ffa8000", + "0x482680017ffa8000", + "0x1e", + "0x4802801c7ffa8000", + "0x4802801d7ffa8000", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x6", + "0x480280137ffa8000", + "0x482680017ffa8000", + "0x17", + "0x480280157ffa8000", + "0x480280167ffa8000", + "0x48127ff37fff8000", + "0x48127ffb7fff8000", + "0x48127ff07fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x17", + "0x4802800b7ffa8000", + "0x482680017ffa8000", + "0xf", + "0x4802800d7ffa8000", + "0x4802800e7ffa8000", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x1d", + "0x480280047ffa8000", + "0x482680017ffa8000", + "0x8", + "0x480280067ffa8000", + "0x480280077ffa8000", + "0x48127fdc7fff8000", + "0x48127ffb7fff8000", + "0x48127fd97fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xa3", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x6c", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x16", + "0x480280007ffb8003", + "0x480280017ffb8003", + "0x4844800180017ffe", + "0x100000000000000000000000000000000", + "0x483080017ffd7ffb", + "0x482480017fff7ffd", + "0x800000000000010fffffffffffffffff7ffffffffffffef0000000000000001", + "0x20680017fff7ffc", + "0x6", + "0x402480017fff7ffd", + "0xffffffffffffffffffffffffffffffff", + "0x10780017fff7fff", + "0x4", + "0x402480017ffe7ffd", + "0xf7ffffffffffffef0000000000000000", + "0x400280027ffb7ffd", + "0x20680017fff7ffe", + "0x51", + "0x402780017fff7fff", + "0x1", + "0x400280007ffb7ffe", + "0x482680017ffb8000", + "0x1", + "0x48307ff980007ffa", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff88000", + "0x1", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff57fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x2a", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x16", + "0x480080007ff88003", + "0x480080017ff78003", + "0x4844800180017ffe", + "0x100000000000000000000000000000000", + "0x483080017ffd7ffb", + "0x482480017fff7ffd", + "0x800000000000010fffffffffffffffff7ffffffffffffef0000000000000001", + "0x20680017fff7ffc", + "0x6", + "0x402480017fff7ffd", + "0xffffffffffffffffffffffffffffffff", + "0x10780017fff7fff", + "0x4", + "0x402480017ffe7ffd", + "0xf7ffffffffffffef0000000000000000", + "0x400080027ff37ffd", + "0x20680017fff7ffe", + "0x11", + "0x402780017fff7fff", + "0x1", + "0x400080007ff87ffe", + "0x40780017fff7fff", + "0x5", + "0x482480017ff38000", + "0x1", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x480680017fff8000", + "0x0", + "0x48127fed7fff8000", + "0x48127ff47fff8000", + "0x10780017fff7fff", + "0x24", + "0x482480017ff38000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x7", + "0x48127ff37fff8000", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x13", + "0x40780017fff7fff", + "0x8", + "0x482680017ffb8000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0xf", + "0x480a7ffb7fff8000", + "0x48127fec7fff8000", + "0x48127fec7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffd", + "0xb", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127fe17fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1a", + "0x480a7ffb7fff8000", + "0x48127fe17fff8000", + "0x48127fe17fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x2691cb735b18f3f656c3b82bd97a32b65d15019b64117513f8604d1e06fe58b", + "0x400280007ff97fff", + "0x400380017ff97ffb", + "0x480280027ff98000", + "0xa0680017fff8005", + "0xe", + "0x4824800180057ffe", + "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8003", + "0x480280007ff67ffc", + "0x480280017ff67ffc", + "0x482480017ffb7ffd", + "0xffffffffffffffeefffffffffffffeff", + "0x400280027ff67ffc", + "0x10780017fff7fff", + "0x11", + "0x48127ffe7fff8005", + "0x484480017ffe8000", + "0x8000000000000000000000000000000", + "0x48307ffe7fff8003", + "0x480280007ff67ffd", + "0x482480017ffc7ffe", + "0xf0000000000000000000000000000100", + "0x480280017ff67ffd", + "0x400280027ff67ff9", + "0x402480017ffd7ff9", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7ffd", + "0x4", + "0x402780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x0", + "0x482680017ff98000", + "0x3", + "0x482680017ff68000", + "0x3", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400280007ffa7fff", + "0x400380017ffa7ff7", + "0x400280027ffa7ffc", + "0x400280037ffa7ffb", + "0x480280057ffa8000", + "0x20680017fff7fff", + "0xe2", + "0x480280047ffa8000", + "0x480680017fff8000", + "0x0", + "0x482480017ff88000", + "0x1", + "0x480280067ffa8000", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400280077ffa7fff", + "0x400280087ffa7ffb", + "0x400280097ffa7ffc", + "0x4002800a7ffa7ffd", + "0x4802800c7ffa8000", + "0x20680017fff7fff", + "0xca", + "0x4802800b7ffa8000", + "0x482680017ffa8000", + "0xe", + "0x4802800d7ffa8000", + "0xa0680017fff8000", + "0x16", + "0x480080007ff38003", + "0x480080017ff28003", + "0x4844800180017ffe", + "0x100000000000000000000000000000000", + "0x483080017ffd7ff6", + "0x482480017fff7ffd", + "0x800000000000010fffffffffffffffff7ffffffffffffef0000000000000001", + "0x20680017fff7ffc", + "0x6", + "0x402480017fff7ffd", + "0xffffffffffffffffffffffffffffffff", + "0x10780017fff7fff", + "0x4", + "0x402480017ffe7ffd", + "0xf7ffffffffffffef0000000000000000", + "0x400080027fee7ffd", + "0x20680017fff7ffe", + "0x9f", + "0x402780017fff7fff", + "0x1", + "0x400080007ff37ff9", + "0xa0680017fff8000", + "0x16", + "0x480080017ff28003", + "0x480080027ff18003", + "0x4844800180017ffe", + "0x100000000000000000000000000000000", + "0x483080017ffd7ffa", + "0x482480017fff7ffd", + "0x800000000000010fffffffffffffffff7ffffffffffffef0000000000000001", + "0x20680017fff7ffc", + "0x6", + "0x402480017fff7ffd", + "0xffffffffffffffffffffffffffffffff", + "0x10780017fff7fff", + "0x4", + "0x402480017ffe7ffd", + "0xf7ffffffffffffef0000000000000000", + "0x400080037fed7ffd", + "0x20680017fff7ffe", + "0x75", + "0x402780017fff7fff", + "0x1", + "0x400080017ff27ffd", + "0x400280007ff87ff8", + "0x400380017ff87ffc", + "0x400280057ff87ffd", + "0x400380067ff87ffd", + "0x480680017fff8000", + "0x2691cb735b18f3f656c3b82bd97a32b65d15019b64117513f8604d1e06fe58b", + "0x400080007ff07fff", + "0x400180017ff07ffb", + "0x480080027ff08000", + "0xa0680017fff8005", + "0xe", + "0x4824800180057ffe", + "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8003", + "0x480080027fec7ffc", + "0x480080037feb7ffc", + "0x482480017ffb7ffd", + "0xffffffffffffffeefffffffffffffeff", + "0x400080047fe97ffc", + "0x10780017fff7fff", + "0x11", + "0x48127ffe7fff8005", + "0x484480017ffe8000", + "0x8000000000000000000000000000000", + "0x48307ffe7fff8003", + "0x480080027fec7ffd", + "0x482480017ffc7ffe", + "0xf0000000000000000000000000000100", + "0x480080037fea7ffd", + "0x400080047fe97ff9", + "0x402480017ffd7ff9", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7ffd", + "0x4", + "0x402780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480280037ff88000", + "0x482680017ff88000", + "0xa", + "0x480280087ff88000", + "0x482480017fe48000", + "0x3", + "0x482480017fe48000", + "0x5", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400080007fec7fff", + "0x400080017fec7feb", + "0x400080027fec7ff9", + "0x400080037fec7ff8", + "0x400080047fec7ffa", + "0x480080067fec8000", + "0x20680017fff7fff", + "0x27", + "0x480080057feb8000", + "0x480680017fff8000", + "0x0", + "0x482480017ff58000", + "0x1", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400080077fe77fff", + "0x400080087fe77ffc", + "0x400080097fe77ffd", + "0x4000800a7fe77ffe", + "0x4000800b7fe77ff7", + "0x4800800d7fe78000", + "0x20680017fff7fff", + "0x11", + "0x40780017fff7fff", + "0x4", + "0x48127ff47fff8000", + "0x4800800c7fe18000", + "0x48127fef7fff8000", + "0x48127ff07fff8000", + "0x482480017fde8000", + "0xe", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x4800800c7fe68000", + "0x482480017fe58000", + "0x10", + "0x4800800e7fe48000", + "0x4800800f7fe38000", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x5", + "0x480080057fe68000", + "0x482480017fe58000", + "0x9", + "0x480080077fe48000", + "0x480080087fe38000", + "0x48127ff47fff8000", + "0x48127ffb7fff8000", + "0x48127fef7fff8000", + "0x48127ff07fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x13", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482480017fd88000", + "0x4", + "0x48127fe07fff8000", + "0x480a7ff87fff8000", + "0x48127fd47fff8000", + "0x48127fde7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x14", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482480017fd88000", + "0x3", + "0x48127fe07fff8000", + "0x480a7ff87fff8000", + "0x48127fd47fff8000", + "0x48127fde7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1b", + "0x4802800b7ffa8000", + "0x482680017ffa8000", + "0xf", + "0x4802800d7ffa8000", + "0x4802800e7ffa8000", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x21", + "0x480280047ffa8000", + "0x482680017ffa8000", + "0x8", + "0x480280067ffa8000", + "0x480280077ffa8000", + "0x48127fd87fff8000", + "0x48127ffb7fff8000", + "0x480a7ff87fff8000", + "0x48127fd47fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x654fd7e67a123dd13868093b3b7777f1ffef596c2e324f25ceaf9146698482c", + "0x480680017fff8000", + "0x4fad269cbf860980e38768fe9cb6b0b9ab03ee3fe84cfde2eccce597c874fd8", + "0x48507fff7fff8000", + "0x48507ffd7ffd8001", + "0x48507ffc80008001", + "0x482480017ffb8001", + "0x6f21413efbe40de150e596d72f7a8c5609ad26c15c915c1f4cdfcb99cee9e89", + "0x483080007fff7ffd", + "0x48307ffc80007ffb", + "0x20680017fff7fff", + "0x106", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x3dbce56de34e1cfe252ead5a1f14fd261d520d343ff6b7652174e62976ef44d", + "0x480680017fff8000", + "0x4b5810004d9272776dec83ecc20c19353453b956e594188890b48467cb53c19", + "0x48507fff7fff8000", + "0x48507ffd7ffd8001", + "0x48507ffc80008001", + "0x482480017ffb8001", + "0x6f21413efbe40de150e596d72f7a8c5609ad26c15c915c1f4cdfcb99cee9e89", + "0x483080007fff7ffd", + "0x48307ffc80007ffb", + "0x20680017fff7fff", + "0xe6", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x20680017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x17", + "0x480a7ffb7fff8000", + "0x48127fe67fff8000", + "0x48127fe67fff8000", + "0x10780017fff7fff", + "0x32", + "0x4800800080068004", + "0x4800800180058004", + "0x4850800380037ffe", + "0x4850800180017ffe", + "0x485080007ffd7ffe", + "0x482480017fff7ffe", + "0x6f21413efbe40de150e596d72f7a8c5609ad26c15c915c1f4cdfcb99cee9e89", + "0x48307ffd7ffc7ffa", + "0x480680017fff8000", + "0x6d232c016ef1b12aec4b7f88cc0b3ab662be3b7dd7adbce5209fcfdbd42a504", + "0x400280007ffb7ffc", + "0x400280017ffb7ffd", + "0x400280027ffb7ff6", + "0x400280037ffb7ff7", + "0x400280047ffb7fff", + "0x480280057ffb8000", + "0x480280067ffb8000", + "0x48127ffc7fff8000", + "0x482680017ffb8000", + "0x7", + "0x480080007ffe8000", + "0x480080017ffd8000", + "0x48307ffe80007ffa", + "0x20680017fff7fff", + "0x5", + "0x40127ffe7fff7ffa", + "0x10780017fff7fff", + "0xf", + "0x48307ffe7ffa8000", + "0x48507ffe80007fff", + "0x48507fff7fff8000", + "0x48307ffa7ff68000", + "0x48307fff80027ffe", + "0x483080017fff7ff4", + "0x48507ffe7ffb7fff", + "0x48307ff380007ffe", + "0x48127ff47fff8000", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x8", + "0x48127ff47fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7fff", + "0x8", + "0x40780017fff7fff", + "0x2a", + "0x48127fb07fff8000", + "0x48127fb07fff8000", + "0x10780017fff7fff", + "0x4c", + "0x20680017fff7fdb", + "0x8", + "0x40780017fff7fff", + "0x2a", + "0x48127fd47fff8000", + "0x48127fd47fff8000", + "0x10780017fff7fff", + "0x44", + "0x4800800080068004", + "0x4800800180058004", + "0x4850800380037ffe", + "0x4850800180017ffe", + "0x485080007ffd7ffe", + "0x482480017fff7ffe", + "0x6f21413efbe40de150e596d72f7a8c5609ad26c15c915c1f4cdfcb99cee9e89", + "0x48307ffd7ffc7ffa", + "0x48307ffd80007ff7", + "0x20680017fff7fff", + "0x4", + "0x402780017fff7fff", + "0x1", + "0x48307ffd80007ff7", + "0x48507ffe80007fff", + "0x48507fff7fff8000", + "0x48307ff97ff38000", + "0x48307fff80027ffe", + "0x483080017fff7ff1", + "0x48507ffe7ffb7fff", + "0x48307ff080007ffe", + "0x48127ffe7fff8000", + "0x48127ffe7fff8000", + "0x48127ff47fff8000", + "0x48307ffd80007fc7", + "0x20680017fff7fff", + "0x4", + "0x402780017fff7fff", + "0x1", + "0x48307ffd80007fc7", + "0x48507ffe80007fff", + "0x48507fff7fff8000", + "0x48307ff97fc38000", + "0x48307fff80027ffe", + "0x483080017fff7fc1", + "0x48507ffe7ffb7fff", + "0x48307fc080007ffe", + "0x48127ffe7fff8000", + "0x48127ffe7fff8000", + "0x48127ff47fff8000", + "0x480080007fff8000", + "0x480080017ffe8000", + "0x48307ffe80007ffb", + "0x20680017fff7fff", + "0x5", + "0x40127ffe7fff7ffb", + "0x10780017fff7fff", + "0xe", + "0x48307ffe7ffb8000", + "0x48507ffe80007fff", + "0x48507fff7fff8000", + "0x48307ffa7ff78000", + "0x48307fff80027ffe", + "0x483080017fff7ff5", + "0x48507ffe7ffb7fff", + "0x48307ff480007ffe", + "0x48127ffe7fff8000", + "0x48127ffe7fff8000", + "0x10780017fff7fff", + "0x8", + "0x40780017fff7fff", + "0x8", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x20680017fff7fff", + "0x13", + "0x40780017fff7fff", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x480a7ffa7fff8000", + "0x48127fc27fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x161bc82433cf4a92809836390ccd14921dfc4dc410cf3d2adbfee5e21ecfec8", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280007ffd7fff", + "0x400380017ffd7ffc", + "0x400280027ffd7ffd", + "0x400280037ffd7ffe", + "0x400280047ffd7ffb", + "0x480280067ffd8000", + "0x20680017fff7fff", + "0x28", + "0x480680017fff8000", + "0x161bc82433cf4a92809836390ccd14921dfc4dc410cf3d2adbfee5e21ecfec8", + "0x480280057ffd8000", + "0x480680017fff8000", + "0x0", + "0x482480017ffd8000", + "0x1", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280077ffd7fff", + "0x400280087ffd7ffc", + "0x400280097ffd7ffd", + "0x4002800a7ffd7ffe", + "0x4002800b7ffd7ff6", + "0x4802800d7ffd8000", + "0x20680017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x4", + "0x480a7ffa7fff8000", + "0x48127fc27fff8000", + "0x4802800c7ffd8000", + "0x482680017ffd8000", + "0xe", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x4802800c7ffd8000", + "0x482680017ffd8000", + "0x10", + "0x4802800e7ffd8000", + "0x4802800f7ffd8000", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x6", + "0x480280057ffd8000", + "0x482680017ffd8000", + "0x9", + "0x480280077ffd8000", + "0x480280087ffd8000", + "0x480a7ffa7fff8000", + "0x48127fc27fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x54", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x5e", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x476574457865637574696f6e496e666f", + "0x400280007ffc7fff", + "0x400380017ffc7ffa", + "0x480280037ffc8000", + "0x20680017fff7fff", + "0x11d", + "0x480280047ffc8000", + "0x480080017fff8000", + "0x480680017fff8000", + "0x2691cb735b18f3f656c3b82bd97a32b65d15019b64117513f8604d1e06fe58b", + "0x400280007ffb7fff", + "0x400380017ffb7ffd", + "0x480280027ffb8000", + "0xa0680017fff8005", + "0xe", + "0x4824800180057ffe", + "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8003", + "0x480280007ff97ffc", + "0x480280017ff97ffc", + "0x482480017ffb7ffd", + "0xffffffffffffffeefffffffffffffeff", + "0x400280027ff97ffc", + "0x10780017fff7fff", + "0x11", + "0x48127ffe7fff8005", + "0x484480017ffe8000", + "0x8000000000000000000000000000000", + "0x48307ffe7fff8003", + "0x480280007ff97ffd", + "0x482480017ffc7ffe", + "0xf0000000000000000000000000000100", + "0x480280017ff97ffd", + "0x400280027ff97ff9", + "0x402480017ffd7ff9", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7ffd", + "0x4", + "0x402780017fff7fff", + "0x1", + "0x480280027ffc8000", + "0x480680017fff8000", + "0x0", + "0x480080007ff48000", + "0x480080017ff38000", + "0x480080027ff28000", + "0x480080037ff18000", + "0x480080047ff08000", + "0x480080057fef8000", + "0x480080067fee8000", + "0x480080077fed8000", + "0x480080087fec8000", + "0x480080097feb8000", + "0x4800800a7fea8000", + "0x4800800b7fe98000", + "0x4800800c7fe88000", + "0x4800800d7fe78000", + "0x4800800e7fe68000", + "0x4800800f7fe58000", + "0x480080107fe48000", + "0x482680017ffb8000", + "0x3", + "0x482680017ff98000", + "0x3", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400280057ffc7fff", + "0x400280067ffc7fea", + "0x400280077ffc7feb", + "0x400280087ffc7fe9", + "0x4802800a7ffc8000", + "0x20680017fff7fff", + "0xc8", + "0x480280097ffc8000", + "0x480680017fff8000", + "0x0", + "0x482480017fe68000", + "0x1", + "0x4802800b7ffc8000", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x4002800c7ffc7fff", + "0x4002800d7ffc7ffb", + "0x4002800e7ffc7ffc", + "0x4002800f7ffc7ffd", + "0x480280117ffc8000", + "0x20680017fff7fff", + "0xb0", + "0x480680017fff8000", + "0x0", + "0x480280107ffc8000", + "0x482680017ffc8000", + "0x13", + "0x480280127ffc8000", + "0x48307fe480007fe5", + "0xa0680017fff8000", + "0x6", + "0x48307ffe80007ffa", + "0x400080007ff07fff", + "0x10780017fff7fff", + "0x91", + "0x482480017ffa8000", + "0x1", + "0x48307fff80007ffd", + "0x400080007fef7fff", + "0x48307ff87fe08000", + "0x480680017fff8000", + "0x1", + "0x480080007ffe8000", + "0x48307fdd80007fde", + "0xa0680017fff8000", + "0x6", + "0x48307ffe80007ffc", + "0x400080017fe97fff", + "0x10780017fff7fff", + "0x70", + "0x482480017ffc8000", + "0x1", + "0x48307fff80007ffd", + "0x400080017fe87fff", + "0x48307ffa7fd98000", + "0x480680017fff8000", + "0x2691cb735b18f3f656c3b82bd97a32b65d15019b64117513f8604d1e06fe58b", + "0x400080007fe57fff", + "0x400180017fe57ffd", + "0x480080027fe58000", + "0xa0680017fff8005", + "0xe", + "0x4824800180057ffe", + "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00", + "0x484480017ffe8000", + "0x110000000000000000", + "0x48307ffe7fff8003", + "0x480080027fe17ffc", + "0x480080037fe07ffc", + "0x482480017ffb7ffd", + "0xffffffffffffffeefffffffffffffeff", + "0x400080047fde7ffc", + "0x10780017fff7fff", + "0x11", + "0x48127ffe7fff8005", + "0x484480017ffe8000", + "0x8000000000000000000000000000000", + "0x48307ffe7fff8003", + "0x480080027fe17ffd", + "0x482480017ffc7ffe", + "0xf0000000000000000000000000000100", + "0x480080037fdf7ffd", + "0x400080047fde7ff9", + "0x402480017ffd7ff9", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7ffd", + "0x4", + "0x402780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x0", + "0x48307ff07fe38000", + "0x480080007ff48000", + "0x482480017fda8000", + "0x3", + "0x482480017fda8000", + "0x5", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400080007fe37fff", + "0x400080017fe37fe2", + "0x400080027fe37ffa", + "0x400080037fe37ff9", + "0x400080047fe37ffb", + "0x480080067fe38000", + "0x20680017fff7fff", + "0x27", + "0x480080057fe28000", + "0x480680017fff8000", + "0x0", + "0x482480017ff68000", + "0x1", + "0x48307ff87fe08000", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400080077fdd7fff", + "0x400080087fdd7ffb", + "0x400080097fdd7ffc", + "0x4000800a7fdd7ffd", + "0x4000800b7fdd7ffe", + "0x4800800d7fdd8000", + "0x20680017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x4", + "0x48127ff37fff8000", + "0x4800800c7fd78000", + "0x48127ff07fff8000", + "0x482480017fd58000", + "0xe", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x4800800c7fdc8000", + "0x482480017fdb8000", + "0x10", + "0x4800800e7fda8000", + "0x4800800f7fd98000", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x6", + "0x480080057fdc8000", + "0x482480017fdb8000", + "0x9", + "0x480080077fda8000", + "0x480080087fd98000", + "0x48127ff37fff8000", + "0x48127ffb7fff8000", + "0x48127ff07fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1a", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e646578206f7574206f6620626f756e6473", + "0x400080007ffe7fff", + "0x482480017fcd8000", + "0x2", + "0x48127fd67fff8000", + "0x48127fca7fff8000", + "0x48127fd57fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x21", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e646578206f7574206f6620626f756e6473", + "0x400080007ffe7fff", + "0x482480017fcd8000", + "0x1", + "0x48127fd67fff8000", + "0x48127fca7fff8000", + "0x48127fd57fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x26", + "0x480280107ffc8000", + "0x482680017ffc8000", + "0x14", + "0x480280127ffc8000", + "0x480280137ffc8000", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x2c", + "0x480280097ffc8000", + "0x482680017ffc8000", + "0xd", + "0x4802800b7ffc8000", + "0x4802800c7ffc8000", + "0x48127fcd7fff8000", + "0x48127ffb7fff8000", + "0x48127fca7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x52", + "0x480a7ff97fff8000", + "0x480280027ffc8000", + "0x480a7ffb7fff8000", + "0x482680017ffc8000", + "0x6", + "0x480680017fff8000", + "0x1", + "0x480280047ffc8000", + "0x480280057ffc8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x7", + "0x480680017fff8000", + "0x7", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0xa0680017fff7fff", + "0x10", + "0x20680017fff7ffd", + "0xe", + "0x20680017fff7ffc", + "0xc", + "0x20680017fff7ffb", + "0x4", + "0x10780017fff7fff", + "0x1b0", + "0x402480017fff7ffb", + "0x1", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x1aa", + "0x482680017ffc8000", + "0x4", + "0x482680017ffc8000", + "0xc", + "0x480680017fff8000", + "0x3", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x482680017ffc8000", + "0x24", + "0x400080007ff97ffb", + "0x400080017ff97ffc", + "0x400080027ff97ffd", + "0x400080037ff97ffe", + "0x482480017ff98000", + "0x4", + "0x48307fff80007ff9", + "0x20680017fff7fff", + "0x1b", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x46a6158a16a947e5916b2a2ca68501a45e93d7110e81aa2d6438b1c57c879a3", + "0x400080007ffe7fff", + "0x480680017fff8000", + "0x0", + "0x400080017ffd7fff", + "0x480680017fff8000", + "0x416c6c20696e707574732068617665206265656e2066696c6c6564", + "0x400080027ffc7fff", + "0x480680017fff8000", + "0x1b", + "0x400080037ffb7fff", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x48127ff57fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff57fff8000", + "0x482480017ff48000", + "0x4", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x6", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x400080007ffa7ffc", + "0x400080017ffa7ffd", + "0x400080027ffa7ffe", + "0x400080037ffa7fff", + "0x482480017ffa8000", + "0x4", + "0x48307fff80007ff3", + "0x20680017fff7fff", + "0x14d", + "0x1104800180018000", + "0x19e0", + "0x482480017fff8000", + "0x19df", + "0x480680017fff8000", + "0x2", + "0x482480017ffe8000", + "0x6", + "0x480680017fff8000", + "0x4", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1", + "0x4824800180007fea", + "0xc", + "0x400080007fff7ffe", + "0x400080017fff7ffd", + "0x400080027fff7ffd", + "0x400080037fff7ffd", + "0x400280007ffa7fe3", + "0x400280017ffa7fe4", + "0x400280027ffa7fe5", + "0x400280037ffa7fe6", + "0x400280047ffa7fff", + "0x400280057ffa7ff9", + "0x400280067ffa7ffa", + "0x400280007ffb7fe3", + "0x400280017ffb7fe4", + "0x400280027ffb7fe5", + "0x400280037ffb7fe6", + "0x400280047ffb7fff", + "0x400280057ffb7ffb", + "0x480280067ffb8000", + "0x484480017fff8000", + "0x7", + "0x48307ffe80007ffa", + "0x20680017fff7fff", + "0xca", + "0x482480017ffc8000", + "0x20", + "0x480080007fff8000", + "0x480080017ffe8000", + "0x480080027ffd8000", + "0x480080037ffc8000", + "0x402780017ffa8000", + "0xe", + "0x40337ff97ffb8006", + "0x48307fff80007fde", + "0x20680017fff7fff", + "0x13", + "0x48307ffd80007fdc", + "0x20680017fff7fff", + "0xb", + "0x48307ffb80007fda", + "0x20680017fff7fff", + "0x5", + "0x48307ff980007fd8", + "0x10780017fff7fff", + "0xd", + "0x48127fff7fff8000", + "0x10780017fff7fff", + "0xa", + "0x40780017fff7fff", + "0x1", + "0x48127ffe7fff8000", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x2", + "0x48127ffd7fff8000", + "0x400080007fe27fff", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x6", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x1104800180018000", + "0xa9f", + "0x402580017fd38005", + "0x1", + "0x20680017fff7fff", + "0x8b", + "0x40780017fff7fff", + "0x1", + "0x480a7ff97fff8000", + "0x48127ffe7fff8000", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x617373657274696f6e206661696c65643a20606f7574707574732e6765745f", + "0x480680017fff8000", + "0x1f", + "0x1104800180018000", + "0xaab", + "0x20680017fff7ffb", + "0x70", + "0x48127ffa7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x6f7574707574286d756c29203d3d2075333834207b206c696d62303a20362c", + "0x480680017fff8000", + "0x1f", + "0x1104800180018000", + "0xa9e", + "0x20680017fff7ffb", + "0x59", + "0x48127ffa7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x206c696d62313a20302c206c696d62323a20302c206c696d62333a2030207d", + "0x480680017fff8000", + "0x1f", + "0x1104800180018000", + "0xa91", + "0x20680017fff7ffb", + "0x42", + "0x48127ffa7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x602e", + "0x480680017fff8000", + "0x2", + "0x1104800180018000", + "0xa84", + "0x20680017fff7ffb", + "0x2b", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x46a6158a16a947e5916b2a2ca68501a45e93d7110e81aa2d6438b1c57c879a3", + "0x400080007ffe7fff", + "0x40137ffa7fff8001", + "0x40137ffb7fff8002", + "0x40137ffc7fff8003", + "0x40137ffd7fff8004", + "0x4829800180008002", + "0x400080017ffd7fff", + "0x48127ff77fff8000", + "0x480a7ffd7fff8000", + "0x480a80017fff8000", + "0x480a80027fff8000", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x2", + "0x1104800180018000", + "0xede", + "0x20680017fff7ffd", + "0x9", + "0x400180007fff8003", + "0x400180017fff8004", + "0x48127ffe7fff8000", + "0x482480017ffe8000", + "0x2", + "0x10780017fff7fff", + "0x4", + "0x48127ffe7fff8000", + "0x48127ffe7fff8000", + "0x48127ff97fff8000", + "0x480a80007fff8000", + "0x480a80067fff8000", + "0x480a80057fff8000", + "0x48127ff67fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x480a80007fff8000", + "0x480a80067fff8000", + "0x480a80057fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x480a80007fff8000", + "0x480a80067fff8000", + "0x480a80057fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x480a80007fff8000", + "0x480a80067fff8000", + "0x480a80057fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x480a80007fff8000", + "0x480a80067fff8000", + "0x480a80057fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff97fff8000", + "0x480a80007fff8000", + "0x480a80067fff8000", + "0x480a80057fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x526573756c743a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48327ffc7ffb8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1", + "0x484480017ff88000", + "0x3", + "0x48307fff7ff28000", + "0x400080027fff7ffc", + "0x480080017fff8000", + "0x480080007ffe8000", + "0x48307ff380007fe2", + "0x400080007fe17ff9", + "0x400080017fe17ff9", + "0x400080027fe17ff9", + "0x400080037fe17ff9", + "0x4800800080007ffe", + "0x400080017fff7ffc", + "0x400080027fff7ffe", + "0x400080047fe07ff2", + "0x48307ff280007fee", + "0x400080057fdf7fff", + "0x400080007ff67fd4", + "0x400080017ff67fd5", + "0x400080027ff67fd6", + "0x400080037ff67fd7", + "0x400080047ff67ff0", + "0x400080057ff67ffe", + "0x400080067ff67ff8", + "0x48307ffc7ff08000", + "0x480080007fff8000", + "0x480080017ffe8000", + "0x480080027ffd8000", + "0x480080037ffc8000", + "0x20680017fff7ffc", + "0x9", + "0x20680017fff7ffd", + "0x7", + "0x20680017fff7ffe", + "0x5", + "0x20680017fff7fff", + "0x3", + "0x40127ff27fff7ff3", + "0x482680017ffa8000", + "0xe", + "0x48127fee7fff8000", + "0x482480017fed8000", + "0x1", + "0x482480017fd78000", + "0x6", + "0x482480017fed8000", + "0x7", + "0x48307ffa80007fcd", + "0x20680017fff7fff", + "0x13", + "0x48307ff880007fcb", + "0x20680017fff7fff", + "0xb", + "0x48307ff680007fc9", + "0x20680017fff7fff", + "0x5", + "0x48307ff480007fc7", + "0x10780017fff7fff", + "0xd", + "0x48127fff7fff8000", + "0x10780017fff7fff", + "0xa", + "0x40780017fff7fff", + "0x1", + "0x48127ffe7fff8000", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x2", + "0x48127ffd7fff8000", + "0x400080007ffa7fff", + "0x480a7ff97fff8000", + "0x48127ff67fff8000", + "0x48127ff97fff8000", + "0x482480017ff78000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff27fff8000", + "0x48127ff27fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x46a6158a16a947e5916b2a2ca68501a45e93d7110e81aa2d6438b1c57c879a3", + "0x400080007ffe7fff", + "0x480680017fff8000", + "0x1", + "0x400080017ffd7fff", + "0x480680017fff8000", + "0x4e6f7420616c6c20696e707574732068617665206265656e2066696c6c6564", + "0x400080027ffc7fff", + "0x480680017fff8000", + "0x0", + "0x400080037ffb7fff", + "0x480680017fff8000", + "0x0", + "0x400080047ffa7fff", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x48127fee7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff47fff8000", + "0x482480017ff38000", + "0x5", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x4", + "0x482680017ffd8000", + "0x8", + "0x480680017fff8000", + "0x3", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x482680017ffd8000", + "0xc", + "0x400080007ff97ffb", + "0x400080017ff97ffc", + "0x400080027ff97ffd", + "0x400080037ff97ffe", + "0x482480017ff98000", + "0x4", + "0x48307fff80007ff9", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x2", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x43616c6c436f6e7472616374", + "0x400280007ff97fff", + "0x400380017ff97ff8", + "0x400380027ff97ffa", + "0x400380037ff97ffb", + "0x400380047ff97ffc", + "0x400380057ff97ffd", + "0x480280077ff98000", + "0x20680017fff7fff", + "0x1c", + "0x40780017fff7fff", + "0xc", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x46a6158a16a947e5916b2a2ca68501a45e93d7110e81aa2d6438b1c57c879a3", + "0x400080007ffe7fff", + "0x480680017fff8000", + "0x0", + "0x400080017ffd7fff", + "0x480680017fff8000", + "0x457870656374656420726576657274", + "0x400080027ffc7fff", + "0x480680017fff8000", + "0xf", + "0x400080037ffb7fff", + "0x480a7ff77fff8000", + "0x480280067ff98000", + "0x482680017ff98000", + "0xa", + "0x480680017fff8000", + "0x1", + "0x48127ff77fff8000", + "0x482480017ff68000", + "0x4", + "0x208b7fff7fff7ffe", + "0x480280087ff98000", + "0x480280097ff98000", + "0x480280067ff98000", + "0x482680017ff98000", + "0xa", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x51", + "0x4824800180007ffc", + "0x1", + "0x480080007fff8000", + "0x4824800180007fff", + "0x454e545259504f494e545f4641494c4544", + "0x20680017fff7fff", + "0x3a", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1275130f95dda36bcbb6e9d28796c1d7e10b6e9fd5ed083e0ede4b12f613528", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400080007ff87fff", + "0x400080017ff87ff7", + "0x400080027ff87ffd", + "0x400080037ff87ffe", + "0x480080057ff88000", + "0x20680017fff7fff", + "0x22", + "0x480080067ff78000", + "0x480080047ff68000", + "0x482480017ff58000", + "0x7", + "0x20680017fff7ffd", + "0xe", + "0x40780017fff7fff", + "0x2", + "0x480a7ff77fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x76616c7565732073686f756c64206e6f74206368616e67652e", + "0x400080007ffe7fff", + "0x480a7ff77fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x5", + "0x480a7ff77fff8000", + "0x480080047ff18000", + "0x482480017ff08000", + "0x8", + "0x480680017fff8000", + "0x1", + "0x480080067fee8000", + "0x480080077fed8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x7", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x556e6578706563746564206572726f72", + "0x400080007ffe7fff", + "0x480a7ff77fff8000", + "0x48127ff07fff8000", + "0x48127ff07fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xa", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x480a7ff77fff8000", + "0x48127ff07fff8000", + "0x48127ff07fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x98", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x12", + "0x4824800180007ffe", + "0x100000000", + "0x4844800180008002", + "0x8000000000000110000000000000000", + "0x4830800080017ffe", + "0x480280007ffb7fff", + "0x482480017ffe8000", + "0xefffffffffffffde00000000ffffffff", + "0x480280017ffb7fff", + "0x400280027ffb7ffb", + "0x402480017fff7ffb", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7fff", + "0x78", + "0x402780017fff7fff", + "0x1", + "0x400280007ffb7ffe", + "0x482480017ffe8000", + "0xffffffffffffffffffffffff00000000", + "0x400280017ffb7fff", + "0x480680017fff8000", + "0x0", + "0x48307ff880007ff9", + "0x48307ffb7ffe8000", + "0xa0680017fff8000", + "0x8", + "0x482480017ffd8000", + "0x1", + "0x48307fff80007ffd", + "0x400280027ffb7fff", + "0x10780017fff7fff", + "0x51", + "0x48307ffe80007ffd", + "0x400280027ffb7fff", + "0x48307ff480007ff5", + "0x48307ffa7ff38000", + "0x48307ffb7ff28000", + "0x48307ff580017ffd", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400280037ffb7fff", + "0x10780017fff7fff", + "0x2f", + "0x400280037ffb7fff", + "0x48307fef80007ff0", + "0x48307ffe7ff28000", + "0xa0680017fff8000", + "0x8", + "0x482480017ffd8000", + "0x1", + "0x48307fff80007ffd", + "0x400280047ffb7fff", + "0x10780017fff7fff", + "0x11", + "0x48307ffe80007ffd", + "0x400280047ffb7fff", + "0x40780017fff7fff", + "0x3", + "0x482680017ffb8000", + "0x5", + "0x480680017fff8000", + "0x0", + "0x48307fea7fe68000", + "0x48307ff77fe58000", + "0x480680017fff8000", + "0x0", + "0x48127ff07fff8000", + "0x48127ff07fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e646578206f7574206f6620626f756e6473", + "0x400080007ffe7fff", + "0x482680017ffb8000", + "0x5", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x4", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482680017ffb8000", + "0x4", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e646578206f7574206f6620626f756e6473", + "0x400080007ffe7fff", + "0x482680017ffb8000", + "0x3", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xc", + "0x482680017ffb8000", + "0x3", + "0x480680017fff8000", + "0x0", + "0x48127fe67fff8000", + "0x48127fe67fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x14", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127fe67fff8000", + "0x48127fe67fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ff88000", + "0xffffffffffffffffffffffffffffe1d8", + "0x400280007ff77fff", + "0x10780017fff7fff", + "0x37", + "0x4825800180007ff8", + "0x1e28", + "0x400280007ff77fff", + "0x482680017ff78000", + "0x1", + "0x20780017fff7ffd", + "0xd", + "0x48127fff7fff8000", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x48127fff7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x1104800180018000", + "0xcc9", + "0x20680017fff7ffc", + "0x11", + "0x400280007ffc7ffd", + "0x400280017ffc7ffe", + "0x400280027ffc7fff", + "0x48127ff97fff8000", + "0x48127fd77fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffb7fff8000", + "0x482680017ffc8000", + "0x3", + "0x4825800180007ffd", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd5", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x48127fd77fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff78000", + "0x1", + "0x480a7ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ff98000", + "0xfffffffffffffffffffffffffffff33a", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x68", + "0x4825800180007ff9", + "0xcc6", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffa80007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffa8000", + "0x1", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffa7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x43", + "0x480080007fff8000", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x1a", + "0x480080007fff8000", + "0x48307fff80007ff9", + "0x20680017fff7fff", + "0xb", + "0x48127ff27fff8000", + "0x48127ff07fff8000", + "0x48127ff27fff8000", + "0x48127ff27fff8000", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc0", + "0x208b7fff7fff7ffe", + "0x48127ff27fff8000", + "0x48127ff07fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127ff27fff8000", + "0x48127ff07fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ff98000", + "0xffffffffffffffffffffffffffffef52", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x7e", + "0x4825800180007ff9", + "0x10ae", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffa80007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffa8000", + "0x3", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffa7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x59", + "0x480080007fff8000", + "0x480080017ffe8000", + "0x480080027ffd8000", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x3", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x2e", + "0x480080007fff8000", + "0x480080017ffe8000", + "0x480080027ffd8000", + "0x48307ffd80007ff5", + "0x20680017fff7fff", + "0x1b", + "0x48307ffd80007ff5", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x1", + "0x10780017fff7fff", + "0x14", + "0x48307ffd80007ff5", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xd", + "0x48127fec7fff8000", + "0x48127fea7fff8000", + "0x48127fec7fff8000", + "0x48127fec7fff8000", + "0x48127ff27fff8000", + "0x48127ff27fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffac", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x48127fec7fff8000", + "0x48127fea7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127feb7fff8000", + "0x48127feb7fff8000", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127ff07fff8000", + "0x48127fee7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ff98000", + "0xffffffffffffffffffffffffffffdd32", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x42", + "0x4825800180007ff9", + "0x22ce", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffa80007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffa8000", + "0x2", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffa7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x1f", + "0x48127ffa7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480080007ffc8000", + "0x480080017ffb8000", + "0x1104800180018000", + "0xc07", + "0x20680017fff7ffd", + "0xb", + "0x48127ffc7fff8000", + "0x48127fce7fff8000", + "0x48127fd07fff8000", + "0x48127fd07fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd1", + "0x208b7fff7fff7ffe", + "0x48127ffc7fff8000", + "0x48127fce7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48297ffa80007ffb", + "0x480680017fff8000", + "0x11", + "0x480280007ff88004", + "0x4824800180037fff", + "0x1", + "0x48307ffe7fff7ffd", + "0x480280017ff87ffe", + "0x480280027ff87fff", + "0x40507ffe7ffa7ffd", + "0x40307fff7ffd7ff9", + "0x482680017ff88000", + "0x3", + "0x4825800180007ffd", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x95", + "0x4825800180007ffd", + "0x1", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x55", + "0x4825800180007ffd", + "0x2", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x49", + "0x4825800180007ffd", + "0x3", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x3d", + "0x4825800180007ffd", + "0x4", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x31", + "0x4825800180007ffd", + "0x5", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x25", + "0x4825800180007ffd", + "0x6", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x19", + "0x4825800180007ffd", + "0x7", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xf", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4b656363616b206c61737420696e70757420776f7264203e3762", + "0x400080007ffe7fff", + "0x48127ff57fff8000", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x100000000000000", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x1000000000000", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x2", + "0x480680017fff8000", + "0x10000000000", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x3", + "0x480680017fff8000", + "0x100000000", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x4", + "0x480680017fff8000", + "0x1000000", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x5", + "0x480680017fff8000", + "0x10000", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x6", + "0x480680017fff8000", + "0x100", + "0x20680017fff7fff", + "0xf", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127ff47fff8000", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480080007ff68004", + "0x4824800180037fff", + "0x1", + "0x48307ffe7fff7ffd", + "0x480080017ff37ffe", + "0x480080027ff27fff", + "0x40507ffe7ffa7ffd", + "0x40317fff7ffd7ffc", + "0xa0680017fff8000", + "0x8", + "0x48307ffe7ff98000", + "0x4824800180007fff", + "0x10000000000000000", + "0x400080037fee7fff", + "0x10780017fff7fff", + "0xb", + "0x48307ffe7ff98001", + "0x4824800180007fff", + "0xffffffffffffffff0000000000000000", + "0x400080037fee7ffe", + "0x482480017fee8000", + "0x4", + "0x48127ffe7fff8000", + "0x10780017fff7fff", + "0x15", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7536345f616464204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fec8000", + "0x4", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x10", + "0x48127fee7fff8000", + "0x480680017fff8000", + "0x1", + "0x4824800180007feb", + "0x10", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x28", + "0x400280007ffb7ffe", + "0x480680017fff8000", + "0x10", + "0x480a7ffa7fff8000", + "0x482680017ffb8000", + "0x1", + "0x48307fe780017ffd", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0xc", + "0x400080007ff87fff", + "0x482480017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffb7fff8000", + "0x1104800180018000", + "0xbab", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x8000000000000000", + "0xa0680017fff8000", + "0x8", + "0x48307ffc7ffe8000", + "0x4824800180007fff", + "0x10000000000000000", + "0x400080007ff97fff", + "0x10780017fff7fff", + "0x10", + "0x48307ffc7ffe8001", + "0x4824800180007fff", + "0xffffffffffffffff0000000000000000", + "0x400080007ff97ffe", + "0x400280007ffb7fff", + "0x482480017ff98000", + "0x1", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffa7fff8000", + "0x482680017ffb8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7536345f616464204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017ff78000", + "0x1", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48297ffa80007ffb", + "0x4825800180007ffd", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6b", + "0x4825800180007ffd", + "0x1", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x18", + "0x4825800180007ffd", + "0x2", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x480680017fff8000", + "0x1000000", + "0x480680017fff8000", + "0x100", + "0x480680017fff8000", + "0x80", + "0x10780017fff7fff", + "0x8", + "0x480680017fff8000", + "0x10000", + "0x480680017fff8000", + "0x10000", + "0x480680017fff8000", + "0x8000", + "0x10780017fff7fff", + "0xa", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x100", + "0x480680017fff8000", + "0x1000000", + "0x480680017fff8000", + "0x800000", + "0x480280007ff98004", + "0x4824800180037fff", + "0x1", + "0x48307ffe7fff7ffb", + "0x480280017ff97ffe", + "0x480280027ff97fff", + "0x40507ffe7ff87ffd", + "0x40317fff7ffd7ffc", + "0x48507ff97fff8000", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ffe", + "0x100000000", + "0x400280037ff97fff", + "0x10780017fff7fff", + "0x28", + "0x482480017ffe8000", + "0xffffffffffffffffffffffff00000000", + "0x400280037ff97fff", + "0xa0680017fff8000", + "0x8", + "0x48307ff67ffc8000", + "0x4824800180007fff", + "0x100000000", + "0x400280047ff97fff", + "0x10780017fff7fff", + "0xe", + "0x48307ff67ffc8001", + "0x4824800180007fff", + "0xffffffffffffffffffffffff00000000", + "0x400280047ff97ffe", + "0x400280007ffb7fff", + "0x482680017ff98000", + "0x5", + "0x480a7ffa7fff8000", + "0x482680017ffb8000", + "0x1", + "0x10780017fff7fff", + "0x29", + "0x40780017fff7fff", + "0x5c", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f616464204f766572666c6f77", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x5", + "0x480680017fff8000", + "0x1", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x5f", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f6d756c204f766572666c6f77", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x4", + "0x480680017fff8000", + "0x1", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xf", + "0x480680017fff8000", + "0x80000000", + "0x400280007ffb7fff", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x482680017ffb8000", + "0x1", + "0x48307ffe80007fff", + "0x480680017fff8000", + "0x1", + "0xa0680017fff8000", + "0x8", + "0x48307ffe7ffd8000", + "0x4824800180007fff", + "0x100000000", + "0x400080007ff87fff", + "0x10780017fff7fff", + "0x71", + "0x48307ffe7ffd8001", + "0x4824800180007fff", + "0xffffffffffffffffffffffff00000000", + "0x400080007ff87ffe", + "0x480680017fff8000", + "0x10", + "0x480080017ff78004", + "0x4824800180037fff", + "0x1", + "0x48307ffe7fff7ffd", + "0x480080027ff47ffe", + "0x480080037ff37fff", + "0x40507ffe7ffa7ffd", + "0x40307fff7ffd7ff9", + "0x480680017fff8000", + "0x10", + "0x48127ff27fff8000", + "0x48127ff27fff8000", + "0x48307ffc80007ffd", + "0x1104800180018000", + "0xb30", + "0x484480017f9b8000", + "0x20", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ffe", + "0x100000000", + "0x400080047faa7fff", + "0x10780017fff7fff", + "0x44", + "0x482480017ffe8000", + "0xffffffffffffffffffffffff00000000", + "0x400080047faa7fff", + "0x484680017ffd8000", + "0x8", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ffe", + "0x100000000", + "0x400080057fa77fff", + "0x10780017fff7fff", + "0x29", + "0x482480017ffe8000", + "0xffffffffffffffffffffffff00000000", + "0x400080057fa77fff", + "0xa0680017fff8000", + "0x8", + "0x48307ffc7ff98000", + "0x4824800180007fff", + "0x100000000", + "0x400080067fa47fff", + "0x10780017fff7fff", + "0x11", + "0x48307ffc7ff98001", + "0x4824800180007fff", + "0xffffffffffffffffffffffff00000000", + "0x400080067fa47ffe", + "0x40780017fff7fff", + "0x2", + "0x400080007ff47ffd", + "0x482480017fa28000", + "0x7", + "0x480680017fff8000", + "0x0", + "0x48127ff17fff8000", + "0x482480017ff18000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f616464204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fa28000", + "0x7", + "0x480680017fff8000", + "0x1", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f6d756c204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fa28000", + "0x6", + "0x480680017fff8000", + "0x1", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f6d756c204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fa28000", + "0x5", + "0x480680017fff8000", + "0x1", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x54", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f616464204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fa28000", + "0x1", + "0x480680017fff8000", + "0x1", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x1", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ff98000", + "0xffffffffffffffffffffffffffffcd10", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x4b", + "0x4825800180007ff9", + "0x32f0", + "0x400280007ff87fff", + "0xa0680017fff8000", + "0x8", + "0x48297ffc80007ffb", + "0x482480017fff8000", + "0xf", + "0x400280017ff87fff", + "0x10780017fff7fff", + "0xf", + "0x482680017ffb8001", + "0x10", + "0x483180007fff7ffc", + "0x400280017ff87ffe", + "0x482680017ff88000", + "0x2", + "0x48127ffe7fff8000", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffb7fff8000", + "0x10780017fff7fff", + "0xa", + "0x482680017ff88000", + "0x2", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x20", + "0x480680017fff8000", + "0x53686132353650726f63657373426c6f636b", + "0x400280007ffa7fff", + "0x400280017ffa7ff6", + "0x400380027ffa7ffd", + "0x400280037ffa7ffe", + "0x480280057ffa8000", + "0x20680017fff7fff", + "0xc", + "0x48127ff97fff8000", + "0x480280047ffa8000", + "0x482680017ffa8000", + "0x7", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480280067ffa8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc8", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x480280047ffa8000", + "0x482680017ffa8000", + "0x8", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480280067ffa8000", + "0x480280077ffa8000", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127ff67fff8000", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x4825800180007ff8", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x8", + "0x4825800180007ff9", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xc5", + "0x480680017fff8000", + "0xfffffffffffffffffffffffffffffffe", + "0x48317fff80017ff9", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400280007ff27fff", + "0x10780017fff7fff", + "0x21", + "0x400280007ff27fff", + "0x482680017ff28000", + "0x1", + "0x4825800180007ff9", + "0xfffffffffffffffffffffffffffffffe", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x5", + "0x48127ffe7fff8000", + "0x10780017fff7fff", + "0xb0", + "0x480680017fff8000", + "0xbaaedce6af48a03bbfd25e8cd0364141", + "0x48317fff80017ff8", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ffa7fff", + "0x10780017fff7fff", + "0x7", + "0x400080007ffb7fff", + "0x482480017ffb8000", + "0x1", + "0x10780017fff7fff", + "0xa1", + "0x482480017ffa8000", + "0x1", + "0x10780017fff7fff", + "0x4", + "0x482680017ff28000", + "0x1", + "0x4825800180007ffa", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x1", + "0x10780017fff7fff", + "0x8", + "0x4825800180007ffb", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x7f", + "0x480680017fff8000", + "0xfffffffffffffffffffffffffffffffe", + "0x48317fff80017ffb", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff97fff", + "0x10780017fff7fff", + "0x21", + "0x400080007ffa7fff", + "0x482480017ffa8000", + "0x1", + "0x4825800180007ffb", + "0xfffffffffffffffffffffffffffffffe", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x5", + "0x48127ffe7fff8000", + "0x10780017fff7fff", + "0x6a", + "0x480680017fff8000", + "0xbaaedce6af48a03bbfd25e8cd0364141", + "0x48317fff80017ffa", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ffa7fff", + "0x10780017fff7fff", + "0x7", + "0x400080007ffb7fff", + "0x482480017ffb8000", + "0x1", + "0x10780017fff7fff", + "0x5b", + "0x482480017ffa8000", + "0x1", + "0x10780017fff7fff", + "0x4", + "0x482480017ff98000", + "0x1", + "0x480a7ff37fff8000", + "0x480a7ff57fff8000", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0xad6", + "0x20680017fff7ffd", + "0x3e", + "0x20680017fff7ffe", + "0x2d", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480a7ff47fff8000", + "0x48127ff97fff8000", + "0x48127ffb7fff8000", + "0x1104800180018000", + "0xd8d", + "0x20680017fff7ffd", + "0x1b", + "0x48317fff80007ffd", + "0x20680017fff7fff", + "0xd", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x496e76616c6964207369676e6174757265", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ff47fff8000", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x482480017ff88000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480a7ff47fff8000", + "0x48127ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480a7ff37fff8000", + "0x480a7ff47fff8000", + "0x480a7ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x5369676e6174757265206f7574206f662072616e6765", + "0x208b7fff7fff7ffe", + "0x480a7ff27fff8000", + "0x480a7ff37fff8000", + "0x480a7ff47fff8000", + "0x480a7ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x5369676e6174757265206f7574206f662072616e6765", + "0x208b7fff7fff7ffe", + "0x4825800180007ff9", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x1", + "0x10780017fff7fff", + "0x8", + "0x4825800180007ffa", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x2fd", + "0x480680017fff8000", + "0xffffffff00000000ffffffffffffffff", + "0x48317fff80017ffa", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400280007ff47fff", + "0x10780017fff7fff", + "0x25", + "0x400280007ff47fff", + "0x482680017ff48000", + "0x1", + "0x4825800180007ffa", + "0xffffffff00000000ffffffffffffffff", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x7", + "0x40780017fff7fff", + "0x2d3", + "0x48127d2b7fff8000", + "0x10780017fff7fff", + "0x2e8", + "0x480680017fff8000", + "0xbce6faada7179e84f3b9cac2fc632551", + "0x48317fff80017ff9", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ffa7fff", + "0x10780017fff7fff", + "0x9", + "0x400080007ffb7fff", + "0x40780017fff7fff", + "0x2d0", + "0x482480017d2b8000", + "0x1", + "0x10780017fff7fff", + "0x2d7", + "0x482480017ffa8000", + "0x1", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x5", + "0x482680017ff48000", + "0x1", + "0x4825800180007ffb", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x40780017fff7fff", + "0x1", + "0x10780017fff7fff", + "0x8", + "0x4825800180007ffc", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x3d", + "0x480680017fff8000", + "0xffffffff00000000ffffffffffffffff", + "0x48317fff80017ffc", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff97fff", + "0x10780017fff7fff", + "0x2b", + "0x400080007ffa7fff", + "0x482480017ffa8000", + "0x1", + "0x4825800180007ffc", + "0xffffffff00000000ffffffffffffffff", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x4", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x28", + "0x480680017fff8000", + "0xbce6faada7179e84f3b9cac2fc632551", + "0x48317fff80017ffb", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ffa7fff", + "0x10780017fff7fff", + "0xb", + "0x400080007ffb7fff", + "0x40780017fff7fff", + "0x1", + "0x482480017ffa8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x15", + "0x482480017ffa8000", + "0x1", + "0x480680017fff8000", + "0x1", + "0x10780017fff7fff", + "0xf", + "0x40780017fff7fff", + "0x5", + "0x482480017ff48000", + "0x1", + "0x480680017fff8000", + "0x1", + "0x10780017fff7fff", + "0x7", + "0x40780017fff7fff", + "0x9", + "0x48127ff47fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1", + "0x48307ffe80007fff", + "0x20680017fff7fff", + "0x272", + "0x480680017fff8000", + "0xbce6faada7179e84f3b9cac2fc632551", + "0x480680017fff8000", + "0xffffffff00000000ffffffffffffffff", + "0xa0680017fff8000", + "0x37", + "0x480080007ff98001", + "0x480080017ff88001", + "0x480080027ff78001", + "0x480080037ff68001", + "0x48307ffe80017ffa", + "0x40780017fff7fff", + "0x12", + "0x20680017fff7fee", + "0x8", + "0x40307fea7fef7fe6", + "0x402480017ff07fef", + "0x1", + "0x400080047fe27ff0", + "0x10780017fff7fff", + "0x3", + "0x400080047fe27fee", + "0x482480017ff98001", + "0x1", + "0x48307ff080018000", + "0x4844800180018000", + "0x100000000000000000000000000000000", + "0x4850800080008000", + "0x48307fff7ff68000", + "0x48307ff67fff8000", + "0x48307ff77fff8000", + "0x48307feb80007fff", + "0x48307feb80007fff", + "0x48307fec80007fff", + "0x4844800180007fff", + "0x100000000000000000000000000000000", + "0x4824800180007fff", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffff8001", + "0x400080057fd67fff", + "0x482480017ffe8000", + "0xffffffffffffffffffffffffffff8000", + "0x400080067fd57fff", + "0x48307ffd7fef8000", + "0x48307ff07fff8000", + "0x48307ff07fff8000", + "0x48307fe680007fff", + "0x48307fe380007fff", + "0x48307fe580007fff", + "0x4844800180007fff", + "0x100000000000000000000000000000000", + "0x4824800180007fff", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffff8001", + "0x400080077fcd7fff", + "0x482480017ffe8000", + "0xffffffffffffffffffffffffffff8000", + "0x400080087fcc7fff", + "0x40307ffd7fea7fe2", + "0x10780017fff7fff", + "0x31", + "0x480080007ff97fff", + "0x480080017ff87fff", + "0x480080027ff77fff", + "0x480080037ff67fff", + "0x480080047ff57fff", + "0x400080057ff47fff", + "0xa0680017fff7ffb", + "0xa", + "0x402480017fff7ff9", + "0x1", + "0x20680017fff7fff", + "0x6", + "0x400680017fff7ff8", + "0x0", + "0x400680017fff7ff7", + "0x1", + "0xa0680017fff7ffa", + "0xc", + "0x48507ff87ffb8001", + "0x48507ff77ffc8001", + "0xa0680017fff8002", + "0x5", + "0x48307ffa7ff88000", + "0x90780017fff7fff", + "0x11", + "0x48127ff57fff8000", + "0x90780017fff7fff", + "0xe", + "0x48507ff97ffa8001", + "0x48507ff87ffb8001", + "0x480680017fff7ff9", + "0x0", + "0x480680017fff7ffa", + "0x0", + "0xa0680017fff8000", + "0x5", + "0x40307ff77ff57ffe", + "0x10780017fff7fff", + "0x3", + "0x40127ff47fff7ffe", + "0x482480017ffe8000", + "0xfffffffffffffffe0000000000000000", + "0x400080067fec7fff", + "0x40317ff97ffb7ffc", + "0x40307ffa7ffc7ff1", + "0x10780017fff7fff", + "0x1bb", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080097fcb8001", + "0x4800800a7fca7ffe", + "0x4000800b7fc97ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7fcd", + "0x48507fd37ffc8000", + "0x48507fd27ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4800800c7fc58001", + "0x4800800d7fc47fff", + "0x4000800e7fc37ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4800800f7fbf7fff", + "0x480080107fbe7ffd", + "0x400080117fbd7fda", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fda7ffe7fff", + "0x40307ffc7ff77fdb", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080127fbc8001", + "0x480080137fbb7ffe", + "0x400080147fba7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7fbe", + "0x48507fc37ffc8000", + "0x48507fc27ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080157fb68001", + "0x480080167fb57fff", + "0x400080177fb47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480080187fb07fff", + "0x480080197faf7ffd", + "0x4000801a7fae7fc9", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fc97ffe7fff", + "0x40307ffc7ff77fca", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x4800801b7fad8001", + "0x4800801c7fac7ffe", + "0x4000801d7fab7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7fae", + "0x48507fb57ffc8000", + "0x48507fb47ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4800801e7fa78001", + "0x4800801f7fa67fff", + "0x400080207fa57ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480080217fa17fff", + "0x480080227fa07ffd", + "0x400080237f9f7fb8", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fb87ffe7fff", + "0x40307ffc7ff77fb9", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080247f9e8001", + "0x480080257f9d7ffe", + "0x400080267f9c7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f9f", + "0x48507fa57ffc8000", + "0x48507fa47ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080277f988001", + "0x480080287f977fff", + "0x400080297f967ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4800802a7f927fff", + "0x4800802b7f917ffd", + "0x4000802c7f907fa7", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fa77ffe7fff", + "0x40307ffc7ff77fa8", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x4800802d7f8f8001", + "0x4800802e7f8e7ffe", + "0x4000802f7f8d7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f95", + "0x48487ffc7ffc8000", + "0x48487ffc7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080307f898001", + "0x480080317f887fff", + "0x400080327f877ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480080337f837fff", + "0x480080347f827ffd", + "0x400080357f817f96", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307f967ffe7fff", + "0x40307ffc7ff77f97", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080367f808001", + "0x480080377f7f7ffe", + "0x400080387f7e7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f86", + "0x48487ffb7ffc8000", + "0x48487ffb7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080397f7a8001", + "0x4800803a7f797fff", + "0x4000803b7f787ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4800803c7f747fff", + "0x4800803d7f737ffd", + "0x4000803e7f727f85", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307f857ffe7fff", + "0x40307ffc7ff77f86", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x4800803f7f718001", + "0x480080407f707ffe", + "0x400080417f6f7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f76", + "0x48487ffc7ffc8000", + "0x48487ffc7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080427f6b8001", + "0x480080437f6a7fff", + "0x400080447f697ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480080457f657fff", + "0x480080467f647ffd", + "0x400080477f637f74", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307f747ffe7fff", + "0x40307ffc7ff77f75", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080487f628001", + "0x480080497f617ffe", + "0x4000804a7f607ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f67", + "0x48487ffb7ffc8000", + "0x48487ffb7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4800804b7f5c8001", + "0x4800804c7f5b7fff", + "0x4000804d7f5a7ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4800804e7f567fff", + "0x4800804f7f557ffd", + "0x400080507f547f63", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307f637ffe7fff", + "0x40307ffc7ff77f64", + "0x482480017f548000", + "0x51", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x48127f597fff8000", + "0x48127f597fff8000", + "0x480680017fff8000", + "0xbce6faada7179e84f3b9cac2fc632551", + "0x480680017fff8000", + "0xffffffff00000000ffffffffffffffff", + "0x1104800180018000", + "0xc06", + "0x48127ffd7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x48127e5d7fff8000", + "0x48127e5d7fff8000", + "0x480680017fff8000", + "0xbce6faada7179e84f3b9cac2fc632551", + "0x480680017fff8000", + "0xffffffff00000000ffffffffffffffff", + "0x1104800180018000", + "0xbfb", + "0x480680017fff8000", + "0x77037d812deb33a0f4a13945d898c296", + "0x480680017fff8000", + "0x6b17d1f2e12c4247f8bce6e563a440f2", + "0x480680017fff8000", + "0x2bce33576b315ececbb6406837bf51f5", + "0x480680017fff8000", + "0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e16", + "0x480680017fff8000", + "0x5365637032353672314e6577", + "0x400280007ff67fff", + "0x400380017ff67ff5", + "0x400280027ff67ffb", + "0x400280037ff67ffc", + "0x400280047ff67ffd", + "0x400280057ff67ffe", + "0x480280077ff68000", + "0x20680017fff7fff", + "0x92", + "0x480280087ff68000", + "0x480280097ff68000", + "0x480280067ff68000", + "0x482680017ff68000", + "0xa", + "0x20680017fff7ffc", + "0x7d", + "0x480680017fff8000", + "0x5365637032353672314d756c", + "0x400080007ffe7fff", + "0x400080017ffe7ffd", + "0x400080027ffe7ffc", + "0x400080037ffe7ef7", + "0x400080047ffe7ef8", + "0x480080067ffe8000", + "0x20680017fff7fff", + "0x68", + "0x480080057ffd8000", + "0x480080077ffc8000", + "0x480680017fff8000", + "0x5365637032353672314d756c", + "0x400080087ffa7fff", + "0x400080097ffa7ffd", + "0x4001800a7ffa7ffd", + "0x4000800b7ffa7fef", + "0x4000800c7ffa7ff0", + "0x4800800e7ffa8000", + "0x20680017fff7fff", + "0x51", + "0x4800800d7ff98000", + "0x4800800f7ff88000", + "0x480680017fff8000", + "0x536563703235367231416464", + "0x400080107ff67fff", + "0x400080117ff67ffd", + "0x400080127ff67ffa", + "0x400080137ff67ffe", + "0x480080157ff68000", + "0x20680017fff7fff", + "0x3b", + "0x480080147ff58000", + "0x480080167ff48000", + "0x480680017fff8000", + "0x5365637032353672314765745879", + "0x400080177ff27fff", + "0x400080187ff27ffd", + "0x400080197ff27ffe", + "0x4800801b7ff28000", + "0x20680017fff7fff", + "0x26", + "0x4800801c7ff18000", + "0x4800801d7ff08000", + "0x4800801a7fef8000", + "0x482480017fee8000", + "0x20", + "0x48287ff980007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x8", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0xd", + "0x48287ffa80007ffc", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x6", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x4", + "0x480680017fff8000", + "0x1", + "0x48127fde7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x7", + "0x48127fde7fff8000", + "0x4800801a7fe98000", + "0x482480017fe88000", + "0x1e", + "0x480680017fff8000", + "0x1", + "0x4800801c7fe68000", + "0x4800801d7fe58000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xb", + "0x48127fde7fff8000", + "0x480080147fe98000", + "0x482480017fe88000", + "0x18", + "0x480680017fff8000", + "0x1", + "0x480080167fe68000", + "0x480080177fe58000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xf", + "0x48127fde7fff8000", + "0x4800800d7fe98000", + "0x482480017fe88000", + "0x11", + "0x480680017fff8000", + "0x1", + "0x4800800f7fe68000", + "0x480080107fe58000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x13", + "0x48127fde7fff8000", + "0x480080057fe98000", + "0x482480017fe88000", + "0x9", + "0x480680017fff8000", + "0x1", + "0x480080077fe68000", + "0x480080087fe58000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xf", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127fed7fff8000", + "0x48127fed7fff8000", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x1", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x15", + "0x480280067ff68000", + "0x482680017ff68000", + "0xa", + "0x480280087ff68000", + "0x480280097ff68000", + "0x48127fde7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x28f", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080077d5c8001", + "0x480080087d5b7ffe", + "0x400080097d5a7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7d5f", + "0x48507d637ffc8000", + "0x48507d627ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4800800a7d568001", + "0x4800800b7d557fff", + "0x4000800c7d547ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4800800d7d507fff", + "0x4800800e7d4f7ffd", + "0x4000800f7d4e7d52", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307d527ffe7fff", + "0x40307ffc7ff77d5c", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080107d4d8001", + "0x480080117d4c7ffe", + "0x400080127d4b7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7d50", + "0x48507d527ffc8000", + "0x48507d517ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080137d478001", + "0x480080147d467fff", + "0x400080157d457ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480080167d417fff", + "0x480080177d407ffd", + "0x400180187d3f7ffb", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40287ffb7ffe7fff", + "0x40307ffc7ff77d4c", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482480017d3d8000", + "0x19", + "0x480a7ff57fff8000", + "0x480a7ff67fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2bf", + "0x48127d3d7fff8000", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x2d8", + "0x480a7ff47fff8000", + "0x480a7ff57fff8000", + "0x480a7ff67fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x48297ffa80007ff6", + "0x20680017fff7fff", + "0x19", + "0x48297ffb80007ff7", + "0x20680017fff7fff", + "0x12", + "0x48297ffc80007ff8", + "0x20680017fff7fff", + "0xb", + "0x48297ffd80007ff9", + "0x20680017fff7fff", + "0x5", + "0x480680017fff8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x10780017fff7fff", + "0x8", + "0x40780017fff7fff", + "0x2", + "0x10780017fff7fff", + "0x4", + "0x40780017fff7fff", + "0x3", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x4825800180007ffd", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x462", + "0xa0680017fff8000", + "0x8", + "0x482a7ffd7ffb8000", + "0x4824800180007fff", + "0x100000000", + "0x400280007ff77fff", + "0x10780017fff7fff", + "0x447", + "0x482a7ffd7ffb8001", + "0x4824800180007fff", + "0xffffffffffffffffffffffff00000000", + "0x400280007ff77ffe", + "0x480680017fff8000", + "0x1f", + "0x48307fff80017ffe", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400280017ff77fff", + "0x10780017fff7fff", + "0x3ab", + "0x400280017ff77fff", + "0x482680017ff78000", + "0x2", + "0x4824800180007ffb", + "0x1f", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x317", + "0x480680017fff8000", + "0x1f", + "0x48307fff80017ff9", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ffa7fff", + "0x10780017fff7fff", + "0x2fa", + "0x400080007ffb7fff", + "0x482480017ffb8000", + "0x1", + "0x4824800180007ffe", + "0x10", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x22b", + "0x480680017fff8000", + "0x10", + "0x48307fff80017ffc", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ffa7fff", + "0x10780017fff7fff", + "0x10d", + "0x400080007ffb7fff", + "0x40780017fff7fff", + "0xf", + "0xa0680017fff8000", + "0x16", + "0x480080017feb8003", + "0x480080027fea8003", + "0x4844800180017ffe", + "0x100000000000000000000000000000000", + "0x483180017ffd7ffc", + "0x482480017fff7ffd", + "0x800000000000010fffffffffffffffff7ffffffffffffef0000000000000001", + "0x20680017fff7ffc", + "0x6", + "0x402480017fff7ffd", + "0xffffffffffffffffffffffffffffffff", + "0x10780017fff7fff", + "0x4", + "0x402480017ffe7ffd", + "0xf7ffffffffffffef0000000000000000", + "0x400080037fe67ffd", + "0x20680017fff7ffe", + "0xe", + "0x402780017fff7fff", + "0x1", + "0x400180017feb7ffc", + "0x40780017fff7fff", + "0x5", + "0x482480017fe68000", + "0x2", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x6", + "0x482480017fe68000", + "0x4", + "0x48127ffe7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x10", + "0x48307fff80017fe1", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff97fff", + "0x10780017fff7fff", + "0xc6", + "0x400080007ffa7fff", + "0x482480017ffa8000", + "0x1", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0xc7b", + "0x20680017fff7ffd", + "0xb7", + "0x20680017fff7fff", + "0xf", + "0x40780017fff7fff", + "0x2a", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127fd07fff8000", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0xbb", + "0x480080007ffc8005", + "0x480080017ffb8005", + "0x4824800180047ffe", + "0x1", + "0x48307ffd7ffe7ffc", + "0x480080027ff87ffd", + "0xa0680017fff7ffd", + "0x6", + "0x482480017ff97ffd", + "0xffffffffffffffff0000000000000000", + "0x10780017fff7fff", + "0x4", + "0x482480017fff7ffd", + "0xffffffffffffffff0000000000000000", + "0x400080037ff57ffc", + "0x40507ffe7ff87ffd", + "0x40307fff7ffd7fe7", + "0x480680017fff8000", + "0x1f", + "0x48287ffb80017fff", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080047ff17fff", + "0x10780017fff7fff", + "0x7f", + "0x400080047ff27fff", + "0x484480017ffc8000", + "0x100000000000000000000000000000000", + "0x480680017fff8000", + "0x10", + "0x48307fe17ffe8000", + "0x48307ffe80017ffc", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080057fec7fff", + "0x10780017fff7fff", + "0x2f", + "0x400080057fed7fff", + "0x480680017fff8000", + "0x10", + "0x48307fff80017ff9", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080067fe97fff", + "0x10780017fff7fff", + "0x16", + "0x400080067fea7fff", + "0x482480017fea8000", + "0x7", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0xc30", + "0x20680017fff7ffd", + "0x7", + "0x48127ffc7fff8000", + "0x484480017ffe8000", + "0x100000000000000000000000000000000", + "0x10780017fff7fff", + "0x22", + "0x40780017fff7fff", + "0xc", + "0x48127ff07fff8000", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x10780017fff7fff", + "0x50", + "0x40780017fff7fff", + "0x17", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fd08000", + "0x7", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x42", + "0x40780017fff7fff", + "0x2", + "0x482480017fea8000", + "0x6", + "0x48127ff67fff8000", + "0x1104800180018000", + "0xc0d", + "0x20680017fff7ffd", + "0x34", + "0x48127ffc7fff8000", + "0x48127ffe7fff8000", + "0x48527fff7ffa8000", + "0x48307fff7fe28000", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x100000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x7000000000000110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff87ffc", + "0x480080017ff77ffc", + "0x402480017ffb7ffd", + "0xf8ffffffffffffeeffffffffffffffff", + "0x400080027ff67ffd", + "0x10780017fff7fff", + "0x16", + "0x484480017fff8001", + "0x1000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff97ffd", + "0x480080017ff87ffd", + "0x402480017ffc7ffe", + "0xff000000000000000000000000000000", + "0x400080027ff77ffe", + "0x40780017fff7fff", + "0x1", + "0x400280007ff97ff9", + "0x482480017ff68000", + "0x3", + "0x480a7ff87fff8000", + "0x482680017ff98000", + "0x1", + "0x48127fdf7fff8000", + "0x480a7ffb7fff8000", + "0x10780017fff7fff", + "0x10d", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482480017ff48000", + "0x3", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x2a", + "0x40780017fff7fff", + "0xc", + "0x48127ff07fff8000", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x10780017fff7fff", + "0x23", + "0x40780017fff7fff", + "0x1f", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fd08000", + "0x5", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x15", + "0x40780017fff7fff", + "0x2c", + "0x48127fd07fff8000", + "0x48127fd17fff8000", + "0x48127fd17fff8000", + "0x10780017fff7fff", + "0xe", + "0x40780017fff7fff", + "0x37", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fc08000", + "0x1", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x16", + "0x480080017ff98003", + "0x480080027ff88003", + "0x4844800180017ffe", + "0x100000000000000000000000000000000", + "0x483180017ffd7ffc", + "0x482480017fff7ffd", + "0x800000000000010fffffffffffffffff7ffffffffffffef0000000000000001", + "0x20680017fff7ffc", + "0x6", + "0x402480017fff7ffd", + "0xffffffffffffffffffffffffffffffff", + "0x10780017fff7fff", + "0x4", + "0x402480017ffe7ffd", + "0xf7ffffffffffffef0000000000000000", + "0x400080037ff47ffd", + "0x20680017fff7ffe", + "0xe", + "0x402780017fff7fff", + "0x1", + "0x400180017ff97ffc", + "0x40780017fff7fff", + "0x5", + "0x482480017ff48000", + "0x2", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x6", + "0x482480017ff48000", + "0x4", + "0x48127ffe7fff8000", + "0x48127ffc7fff8000", + "0x48127ffd7fff8000", + "0x48127fef7fff8000", + "0x1104800180018000", + "0xb7f", + "0x20680017fff7ffd", + "0xdd", + "0x20680017fff7fff", + "0xf", + "0x40780017fff7fff", + "0x3b", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127fbf7fff8000", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0xd3", + "0x480080007ffc8005", + "0x480080017ffb8005", + "0x4824800180047ffe", + "0x1", + "0x48307ffd7ffe7ffc", + "0x480080027ff87ffd", + "0xa0680017fff7ffd", + "0x6", + "0x482480017ff97ffd", + "0xffffffffffffffff0000000000000000", + "0x10780017fff7fff", + "0x4", + "0x482480017fff7ffd", + "0xffffffffffffffff0000000000000000", + "0x400080037ff57ffc", + "0x40507ffe7ff87ffd", + "0x40307fff7ffd7fe9", + "0x480680017fff8000", + "0x10", + "0x48307fda80017fff", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080047ff17fff", + "0x10780017fff7fff", + "0xa5", + "0x400080047ff27fff", + "0x482480017ff28000", + "0x5", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0xb4d", + "0x20680017fff7ffd", + "0x96", + "0x480680017fff8000", + "0x1f", + "0x48287ffb80017fff", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff87fff", + "0x10780017fff7fff", + "0x7e", + "0x400080007ff97fff", + "0x48507ffc7fd68000", + "0x480680017fff8000", + "0x10", + "0x48307fe87ffe8000", + "0x48307ffe80017ffc", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080017ff37fff", + "0x10780017fff7fff", + "0x2f", + "0x400080017ff47fff", + "0x480680017fff8000", + "0x10", + "0x48307fff80017ff9", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080027ff07fff", + "0x10780017fff7fff", + "0x16", + "0x400080027ff17fff", + "0x482480017ff18000", + "0x3", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0xb23", + "0x20680017fff7ffd", + "0x7", + "0x48127ffc7fff8000", + "0x484480017ffe8000", + "0x100000000000000000000000000000000", + "0x10780017fff7fff", + "0x22", + "0x40780017fff7fff", + "0xc", + "0x48127ff07fff8000", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x10780017fff7fff", + "0x50", + "0x40780017fff7fff", + "0x17", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fd78000", + "0x3", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x42", + "0x40780017fff7fff", + "0x2", + "0x482480017ff18000", + "0x2", + "0x48127ff67fff8000", + "0x1104800180018000", + "0xb00", + "0x20680017fff7ffd", + "0x34", + "0x48127ffc7fff8000", + "0x48127ffe7fff8000", + "0x48527fff7ffa8000", + "0x48307fff7fe98000", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x100000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x7000000000000110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff87ffc", + "0x480080017ff77ffc", + "0x402480017ffb7ffd", + "0xf8ffffffffffffeeffffffffffffffff", + "0x400080027ff67ffd", + "0x10780017fff7fff", + "0x16", + "0x484480017fff8001", + "0x1000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff97ffd", + "0x480080017ff87ffd", + "0x402480017ffc7ffe", + "0xff000000000000000000000000000000", + "0x400080027ff77ffe", + "0x40780017fff7fff", + "0x1", + "0x400280007ff97ff9", + "0x482480017ff68000", + "0x3", + "0x480a7ff87fff8000", + "0x482680017ff98000", + "0x1", + "0x48127fc87fff8000", + "0x480a7ffb7fff8000", + "0x10780017fff7fff", + "0xdc", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482480017ff48000", + "0x3", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x31", + "0x40780017fff7fff", + "0xc", + "0x48127ff07fff8000", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x10780017fff7fff", + "0x2a", + "0x40780017fff7fff", + "0x1f", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fd78000", + "0x1", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x1c", + "0x40780017fff7fff", + "0x25", + "0x48127fd77fff8000", + "0x48127fd87fff8000", + "0x48127fd87fff8000", + "0x10780017fff7fff", + "0x15", + "0x40780017fff7fff", + "0x30", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fbf8000", + "0x5", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x7", + "0x40780017fff7fff", + "0x3d", + "0x48127fbf7fff8000", + "0x48127fc07fff8000", + "0x48127fc07fff8000", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2c", + "0xa0680017fff8000", + "0x16", + "0x480080007fd18003", + "0x480080017fd08003", + "0x4844800180017ffe", + "0x100000000000000000000000000000000", + "0x483180017ffd7ffc", + "0x482480017fff7ffd", + "0x800000000000010fffffffffffffffff7ffffffffffffef0000000000000001", + "0x20680017fff7ffc", + "0x6", + "0x402480017fff7ffd", + "0xffffffffffffffffffffffffffffffff", + "0x10780017fff7fff", + "0x4", + "0x402480017ffe7ffd", + "0xf7ffffffffffffef0000000000000000", + "0x400080027fcc7ffd", + "0x20680017fff7ffe", + "0xe", + "0x402780017fff7fff", + "0x1", + "0x400180007fd17ffc", + "0x40780017fff7fff", + "0x5", + "0x482480017fcc8000", + "0x1", + "0x480a7ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x6", + "0x482480017fcc8000", + "0x3", + "0x48127ffe7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x1f", + "0x48287ffb80017fff", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff97fff", + "0x10780017fff7fff", + "0x82", + "0x400080007ffa7fff", + "0x480680017fff8000", + "0x10", + "0x48307fff80017ffe", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080017ff67fff", + "0x10780017fff7fff", + "0x2f", + "0x400080017ff77fff", + "0x480680017fff8000", + "0x10", + "0x48307fff80017ffb", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080027ff37fff", + "0x10780017fff7fff", + "0x16", + "0x400080027ff47fff", + "0x482480017ff48000", + "0x3", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0xa47", + "0x20680017fff7ffd", + "0x7", + "0x48127ffc7fff8000", + "0x484480017ffe8000", + "0x100000000000000000000000000000000", + "0x10780017fff7fff", + "0x22", + "0x40780017fff7fff", + "0xc", + "0x48127ff07fff8000", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x10780017fff7fff", + "0x56", + "0x40780017fff7fff", + "0x17", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fda8000", + "0x3", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x48", + "0x40780017fff7fff", + "0x2", + "0x482480017ff48000", + "0x2", + "0x48127ff87fff8000", + "0x1104800180018000", + "0xa24", + "0x20680017fff7ffd", + "0x3a", + "0x48127ffc7fff8000", + "0x48127ffe7fff8000", + "0x48527fff7ffa8000", + "0x48307fff7fe58000", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x100000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x7000000000000110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff87ffc", + "0x480080017ff77ffc", + "0x402480017ffb7ffd", + "0xf8ffffffffffffeeffffffffffffffff", + "0x400080027ff67ffd", + "0x10780017fff7fff", + "0x1c", + "0x484480017fff8001", + "0x1000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff97ffd", + "0x480080017ff87ffd", + "0x402480017ffc7ffe", + "0xff000000000000000000000000000000", + "0x400080027ff77ffe", + "0x40780017fff7fff", + "0x1", + "0x400280007ff97ff9", + "0x482480017ff68000", + "0x3", + "0x480a7ff87fff8000", + "0x482680017ff98000", + "0x1", + "0x48127fda7fff8000", + "0x480a7ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127f9d7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482480017ff48000", + "0x3", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x15", + "0x40780017fff7fff", + "0xc", + "0x48127ff07fff8000", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x10780017fff7fff", + "0xe", + "0x40780017fff7fff", + "0x1d", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fda8000", + "0x1", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x5a", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017f9e8000", + "0x1", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x40", + "0x480680017fff8000", + "0x10", + "0x48317fff80017ffd", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007fba7fff", + "0x10780017fff7fff", + "0x2f", + "0x400080007fbb7fff", + "0x480680017fff8000", + "0x10", + "0x48317fff80017ffd", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080017fb77fff", + "0x10780017fff7fff", + "0x16", + "0x400080017fb87fff", + "0x482480017fb88000", + "0x2", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x99d", + "0x20680017fff7ffd", + "0x7", + "0x48127ffc7fff8000", + "0x484480017ffe8000", + "0x100000000000000000000000000000000", + "0x10780017fff7fff", + "0x22", + "0x40780017fff7fff", + "0x9", + "0x48127ff37fff8000", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x10780017fff7fff", + "0x58", + "0x40780017fff7fff", + "0x14", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fa18000", + "0x2", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x4a", + "0x40780017fff7fff", + "0x2", + "0x482480017fb88000", + "0x1", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x97a", + "0x20680017fff7ffd", + "0x3c", + "0x48127ffc7fff8000", + "0x48127ffe7fff8000", + "0x48527fff7ffa8000", + "0x48327fff7ffc8000", + "0xa0680017fff8004", + "0xe", + "0x4824800180047ffe", + "0x100000000000000000000000000000000000000000000000000000000000000", + "0x484480017ffe8000", + "0x7000000000000110000000000000000", + "0x48307ffe7fff8002", + "0x480080007ff87ffc", + "0x480080017ff77ffc", + "0x402480017ffb7ffd", + "0xf8ffffffffffffeeffffffffffffffff", + "0x400080027ff67ffd", + "0x10780017fff7fff", + "0x19", + "0x484480017fff8001", + "0x1000000000000000000000000000000", + "0x48307fff80007ffd", + "0x480080007ff97ffd", + "0x480080017ff87ffd", + "0x402480017ffc7ffe", + "0xff000000000000000000000000000000", + "0x400080027ff77ffe", + "0x40780017fff7fff", + "0x3", + "0x400280007ff97ff7", + "0x482480017ff48000", + "0x3", + "0x480680017fff8000", + "0x0", + "0x480a7ff87fff8000", + "0x482680017ff98000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482480017ff48000", + "0x3", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x9", + "0x48127ff37fff8000", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x44", + "0x482680017ff78000", + "0x2", + "0x4825800180007ffb", + "0x0", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x7c", + "0x480680017fff8000", + "0x10", + "0x48317fff80017ffd", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ffa7fff", + "0x10780017fff7fff", + "0x2f", + "0x400080007ffb7fff", + "0x480680017fff8000", + "0x10", + "0x48317fff80017ffd", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080017ff77fff", + "0x10780017fff7fff", + "0x16", + "0x400080017ff87fff", + "0x482480017ff88000", + "0x2", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x90a", + "0x20680017fff7ffd", + "0x7", + "0x48127ffc7fff8000", + "0x484480017ffe8000", + "0x100000000000000000000000000000000", + "0x10780017fff7fff", + "0x22", + "0x40780017fff7fff", + "0x4", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x10780017fff7fff", + "0x49", + "0x40780017fff7fff", + "0xf", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017fe68000", + "0x2", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0x3b", + "0x40780017fff7fff", + "0x2", + "0x482480017ff88000", + "0x1", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x8e7", + "0x20680017fff7ffd", + "0x2d", + "0x48127ffc7fff8000", + "0x48127ffe7fff8000", + "0xa0680017fff8000", + "0x8", + "0x482a7ffd7ffb8000", + "0x4824800180007fff", + "0x100000000", + "0x400080007ffb7fff", + "0x10780017fff7fff", + "0x12", + "0x482a7ffd7ffb8001", + "0x4824800180007fff", + "0xffffffffffffffffffffffff00000000", + "0x400080007ffb7ffe", + "0x40780017fff7fff", + "0x1", + "0x48527ffb7ffa8000", + "0x482480017ff98000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x48327ffb7ffc8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f616464204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017ff98000", + "0x1", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x4", + "0x48127ff87fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1b", + "0x48127fe37fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x63", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f616464204f766572666c6f77", + "0x400080007ffe7fff", + "0x482680017ff78000", + "0x1", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x68", + "0x480a7ff77fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ff98000", + "0xfffffffffffffffffffffffffffff722", + "0x400280007ff87fff", + "0x10780017fff7fff", + "0x2f", + "0x4825800180007ff9", + "0x8de", + "0x400280007ff87fff", + "0x482680017ff88000", + "0x1", + "0x48297ffa80007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffa8000", + "0x1", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffa7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0xe", + "0x480080007fff8000", + "0x400280007ffd7fff", + "0x48127ff97fff8000", + "0x48127ff77fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffc7fff8000", + "0x482680017ffd8000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd7", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x1", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x48297ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffc8000", + "0x1", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x480280007ffc8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x8f", + "0x48307ffc80007ffd", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ffb8000", + "0x1", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x6c", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x12", + "0x4824800180007ffe", + "0x10000000000000000", + "0x4844800180008002", + "0x8000000000000110000000000000000", + "0x4830800080017ffe", + "0x480280007ffb7fff", + "0x482480017ffe8000", + "0xefffffffffffffdeffffffffffffffff", + "0x480280017ffb7fff", + "0x400280027ffb7ffb", + "0x402480017fff7ffb", + "0xffffffffffffffffffffffffffffffff", + "0x20680017fff7fff", + "0x55", + "0x402780017fff7fff", + "0x1", + "0x400280007ffb7ffe", + "0x482480017ffe8000", + "0xffffffffffffffff0000000000000000", + "0x400280017ffb7fff", + "0x482680017ffb8000", + "0x2", + "0x48307ff880007ff9", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482480017ff78000", + "0x1", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff47fff8000", + "0x10780017fff7fff", + "0x8", + "0x48127ff77fff8000", + "0x48127ff77fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x2a", + "0x480080007fff8000", + "0xa0680017fff8000", + "0x16", + "0x480080007ff88003", + "0x480080017ff78003", + "0x4844800180017ffe", + "0x100000000000000000000000000000000", + "0x483080017ffd7ffb", + "0x482480017fff7ffd", + "0x800000000000010fffffffffffffffff7ffffffffffffef0000000000000001", + "0x20680017fff7ffc", + "0x6", + "0x402480017fff7ffd", + "0xffffffffffffffffffffffffffffffff", + "0x10780017fff7fff", + "0x4", + "0x402480017ffe7ffd", + "0xf7ffffffffffffef0000000000000000", + "0x400080027ff37ffd", + "0x20680017fff7ffe", + "0x11", + "0x402780017fff7fff", + "0x1", + "0x400080007ff87ffe", + "0x40780017fff7fff", + "0x5", + "0x482480017ff38000", + "0x1", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x480680017fff8000", + "0x0", + "0x48127fe67fff8000", + "0x48127feb7fff8000", + "0x48127ff37fff8000", + "0x208b7fff7fff7ffe", + "0x482480017ff38000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x7", + "0x48127ff37fff8000", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x8", + "0x482680017ffb8000", + "0x3", + "0x10780017fff7fff", + "0x5", + "0x40780017fff7fff", + "0x10", + "0x480a7ffb7fff8000", + "0x48127feb7fff8000", + "0x48127feb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x15", + "0x480a7ffb7fff8000", + "0x48127fe67fff8000", + "0x48127fe67fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x10000000000000000", + "0x480280007ff98005", + "0x480280017ff98005", + "0x4824800180047ffe", + "0x1", + "0x48307ffd7ffe7ffc", + "0x480280027ff97ffd", + "0xa0680017fff7ffd", + "0x6", + "0x482480017ff97ffd", + "0xffffffffffffffff0000000000000000", + "0x10780017fff7fff", + "0x4", + "0x482480017fff7ffd", + "0xffffffffffffffff0000000000000000", + "0x400280037ff97ffc", + "0x40507ffe7ff87ffd", + "0x40317fff7ffd7ffc", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ffd", + "0x10000000000000000", + "0x400280047ff97fff", + "0x10780017fff7fff", + "0x73", + "0x482480017ffd8000", + "0xffffffffffffffff0000000000000000", + "0x400280047ff97fff", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ffc", + "0x10000000000000000", + "0x400280057ff97fff", + "0x10780017fff7fff", + "0x5b", + "0x482480017ffc8000", + "0xffffffffffffffff0000000000000000", + "0x400280057ff97fff", + "0x400280007ffb7ffb", + "0x400280017ffb7ffa", + "0x480680017fff8000", + "0x10000000000000000", + "0x480280067ff98005", + "0x480280077ff98005", + "0x4824800180047ffe", + "0x1", + "0x48307ffd7ffe7ffc", + "0x480280087ff97ffd", + "0xa0680017fff7ffd", + "0x6", + "0x482480017ff97ffd", + "0xffffffffffffffff0000000000000000", + "0x10780017fff7fff", + "0x4", + "0x482480017fff7ffd", + "0xffffffffffffffff0000000000000000", + "0x400280097ff97ffc", + "0x40507ffe7ff87ffd", + "0x40317fff7ffd7ffd", + "0x480a7ffa7fff8000", + "0x482680017ffb8000", + "0x2", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ffb", + "0x10000000000000000", + "0x4002800a7ff97fff", + "0x10780017fff7fff", + "0x27", + "0x482480017ffb8000", + "0xffffffffffffffff0000000000000000", + "0x4002800a7ff97fff", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ffa", + "0x10000000000000000", + "0x4002800b7ff97fff", + "0x10780017fff7fff", + "0x11", + "0x482480017ffa8000", + "0xffffffffffffffff0000000000000000", + "0x4002800b7ff97fff", + "0x40780017fff7fff", + "0x5", + "0x400080007ff67ff4", + "0x400080017ff67ff3", + "0x482680017ff98000", + "0xc", + "0x480680017fff8000", + "0x0", + "0x48127ff37fff8000", + "0x482480017ff38000", + "0x2", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0xc", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0xe", + "0x40780017fff7fff", + "0x2", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0xb", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0xe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x6", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0xe", + "0x40780017fff7fff", + "0x10", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x5", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x482680017ffa8000", + "0xfffffffffffffffffffffffffffff740", + "0x400280007ff97fff", + "0x10780017fff7fff", + "0x40", + "0x4825800180007ffa", + "0x8c0", + "0x400280007ff97fff", + "0x482680017ff98000", + "0x1", + "0x4825800180007ffd", + "0x1", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0x2a", + "0x480680017fff8000", + "0x0", + "0x400280007ffc7fff", + "0x480680017fff8000", + "0x1", + "0x480a7ffb7fff8000", + "0x482680017ffc8000", + "0x1", + "0x48317ffd80017ffd", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff77fff", + "0x10780017fff7fff", + "0xc", + "0x400080007ff87fff", + "0x482480017ff88000", + "0x1", + "0x48127ff67fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffb7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd8", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x7533325f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x482480017ff58000", + "0x1", + "0x48127ff37fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x8000000000000000", + "0x400280007ffc7fff", + "0x48127ffd7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffb7fff8000", + "0x482680017ffc8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff98000", + "0x1", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x3d", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400280007ffc7fff", + "0x4825800180007ffd", + "0x1", + "0x480a7ffb7fff8000", + "0x482680017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x39", + "0x48127fc57fff8000", + "0x48127fc57fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0x2", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x35", + "0x48127fc97fff8000", + "0x48127fc97fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0x3", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x31", + "0x48127fcd7fff8000", + "0x48127fcd7fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0x4", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x2d", + "0x48127fd17fff8000", + "0x48127fd17fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0x5", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x29", + "0x48127fd57fff8000", + "0x48127fd57fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0x6", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x25", + "0x48127fd97fff8000", + "0x48127fd97fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0x7", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x21", + "0x48127fdd7fff8000", + "0x48127fdd7fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0x8", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x1d", + "0x48127fe17fff8000", + "0x48127fe17fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0x9", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x19", + "0x48127fe57fff8000", + "0x48127fe57fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0xa", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x15", + "0x48127fe97fff8000", + "0x48127fe97fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0xb", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x11", + "0x48127fed7fff8000", + "0x48127fed7fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0xc", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0xd", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0xd", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x9", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0xe", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x5", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x4825800180007ffd", + "0xf", + "0x48127ffc7fff8000", + "0x482480017ffc8000", + "0x1", + "0x20680017fff7ffd", + "0x7", + "0x40780017fff7fff", + "0x1", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x0", + "0x400080007ffe7fff", + "0x48127ffd7fff8000", + "0x482480017ffd8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x536563703235366b31476574506f696e7446726f6d58", + "0x400280007ff67fff", + "0x400380017ff67ff5", + "0x400380027ff67ff9", + "0x400380037ff67ffa", + "0x400380047ff67ffd", + "0x480280067ff68000", + "0x20680017fff7fff", + "0x2af", + "0x480280077ff68000", + "0x480280087ff68000", + "0x480280057ff68000", + "0x482680017ff68000", + "0x9", + "0x20680017fff7ffc", + "0x29c", + "0x480680017fff8000", + "0x29bfcdb2dce28d959f2815b16f81798", + "0x480680017fff8000", + "0x79be667ef9dcbbac55a06295ce870b07", + "0x480680017fff8000", + "0xfd17b448a68554199c47d08ffb10d4b8", + "0x480680017fff8000", + "0x483ada7726a3c4655da4fbfc0e1108a8", + "0x480680017fff8000", + "0x536563703235366b314e6577", + "0x400080007ffa7fff", + "0x400080017ffa7ff9", + "0x400080027ffa7ffb", + "0x400080037ffa7ffc", + "0x400080047ffa7ffd", + "0x400080057ffa7ffe", + "0x480080077ffa8000", + "0x20680017fff7fff", + "0x27a", + "0x480080087ff98000", + "0x480080097ff88000", + "0x480080067ff78000", + "0x482480017ff68000", + "0xa", + "0x20680017fff7ffc", + "0x265", + "0x480680017fff8000", + "0xbaaedce6af48a03bbfd25e8cd0364141", + "0x480680017fff8000", + "0xfffffffffffffffffffffffffffffffe", + "0xa0680017fff8000", + "0x37", + "0x480280007ff48001", + "0x480280017ff48001", + "0x480280027ff48001", + "0x480280037ff48001", + "0x48307ffe80017ffa", + "0x40780017fff7fff", + "0x12", + "0x20680017fff7fee", + "0x8", + "0x40307fea7fef7fe6", + "0x402480017ff07fef", + "0x1", + "0x400280047ff47ff0", + "0x10780017fff7fff", + "0x3", + "0x400280047ff47fee", + "0x482480017ff98001", + "0x1", + "0x48307ff080018000", + "0x4844800180018000", + "0x100000000000000000000000000000000", + "0x4850800080008000", + "0x48307fff7ff68000", + "0x48307ff67fff8000", + "0x48307ff77fff8000", + "0x48307feb80007fff", + "0x48307feb80007fff", + "0x48307fec80007fff", + "0x4844800180007fff", + "0x100000000000000000000000000000000", + "0x4824800180007fff", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffff8001", + "0x400280057ff47fff", + "0x482480017ffe8000", + "0xffffffffffffffffffffffffffff8000", + "0x400280067ff47fff", + "0x48307ffd7fef8000", + "0x48307ff07fff8000", + "0x48307ff07fff8000", + "0x48307fe680007fff", + "0x48307fe380007fff", + "0x48307fe580007fff", + "0x4844800180007fff", + "0x100000000000000000000000000000000", + "0x4824800180007fff", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffff8001", + "0x400280077ff47fff", + "0x482480017ffe8000", + "0xffffffffffffffffffffffffffff8000", + "0x400280087ff47fff", + "0x40307ffd7fea7fe2", + "0x10780017fff7fff", + "0x31", + "0x480280007ff47fff", + "0x480280017ff47fff", + "0x480280027ff47fff", + "0x480280037ff47fff", + "0x480280047ff47fff", + "0x400280057ff47fff", + "0xa0680017fff7ffb", + "0xa", + "0x402480017fff7ff9", + "0x1", + "0x20680017fff7fff", + "0x6", + "0x400680017fff7ff8", + "0x0", + "0x400680017fff7ff7", + "0x1", + "0xa0680017fff7ffa", + "0xc", + "0x48507ff87ffb8001", + "0x48507ff77ffc8001", + "0xa0680017fff8002", + "0x5", + "0x48307ffa7ff88000", + "0x90780017fff7fff", + "0x11", + "0x48127ff57fff8000", + "0x90780017fff7fff", + "0xe", + "0x48507ff97ffa8001", + "0x48507ff87ffb8001", + "0x480680017fff7ff9", + "0x0", + "0x480680017fff7ffa", + "0x0", + "0xa0680017fff8000", + "0x5", + "0x40307ff77ff57ffe", + "0x10780017fff7fff", + "0x3", + "0x40127ff47fff7ffe", + "0x482480017ffe8000", + "0xfffffffffffffffe0000000000000000", + "0x400280067ff47fff", + "0x40317ff97ffb7ffa", + "0x40307ffa7ffc7ff1", + "0x10780017fff7fff", + "0x1ae", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480280097ff48001", + "0x4802800a7ff47ffe", + "0x4002800b7ff47ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7fcd", + "0x48507fd37ffc8000", + "0x48507fd27ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4802800c7ff48001", + "0x4802800d7ff47fff", + "0x4002800e7ff47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4802800f7ff47fff", + "0x480280107ff47ffd", + "0x400280117ff47fda", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fda7ffe7fff", + "0x40307ffc7ff77fdb", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480280127ff48001", + "0x480280137ff47ffe", + "0x400280147ff47ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7fbe", + "0x48507fc37ffc8000", + "0x48507fc27ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480280157ff48001", + "0x480280167ff47fff", + "0x400280177ff47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480280187ff47fff", + "0x480280197ff47ffd", + "0x4002801a7ff47fc9", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fc97ffe7fff", + "0x40307ffc7ff77fca", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x4802801b7ff48001", + "0x4802801c7ff47ffe", + "0x4002801d7ff47ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7fae", + "0x48507fb57ffc8000", + "0x48507fb47ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4802801e7ff48001", + "0x4802801f7ff47fff", + "0x400280207ff47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480280217ff47fff", + "0x480280227ff47ffd", + "0x400280237ff47fb8", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fb87ffe7fff", + "0x40307ffc7ff77fb9", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480280247ff48001", + "0x480280257ff47ffe", + "0x400280267ff47ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f9f", + "0x48507fa57ffc8000", + "0x48507fa47ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480280277ff48001", + "0x480280287ff47fff", + "0x400280297ff47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4802802a7ff47fff", + "0x4802802b7ff47ffd", + "0x4002802c7ff47fa7", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fa77ffe7fff", + "0x40307ffc7ff77fa8", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x4802802d7ff48001", + "0x4802802e7ff47ffe", + "0x4002802f7ff47ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f95", + "0x48487ffa7ffc8000", + "0x48487ffa7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480280307ff48001", + "0x480280317ff47fff", + "0x400280327ff47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480280337ff47fff", + "0x480280347ff47ffd", + "0x400280357ff47f96", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307f967ffe7fff", + "0x40307ffc7ff77f97", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480280367ff48001", + "0x480280377ff47ffe", + "0x400280387ff47ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f86", + "0x48487ff97ffc8000", + "0x48487ff97ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480280397ff48001", + "0x4802803a7ff47fff", + "0x4002803b7ff47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4802803c7ff47fff", + "0x4802803d7ff47ffd", + "0x4002803e7ff47f85", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307f857ffe7fff", + "0x40307ffc7ff77f86", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x4802803f7ff48001", + "0x480280407ff47ffe", + "0x400280417ff47ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f76", + "0x48487ffa7ffc8000", + "0x48487ffa7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480280427ff48001", + "0x480280437ff47fff", + "0x400280447ff47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480280457ff47fff", + "0x480280467ff47ffd", + "0x400280477ff47f74", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307f747ffe7fff", + "0x40307ffc7ff77f75", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480280487ff48001", + "0x480280497ff47ffe", + "0x4002804a7ff47ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f67", + "0x48487ff97ffc8000", + "0x48487ff97ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4802804b7ff48001", + "0x4802804c7ff47fff", + "0x4002804d7ff47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4802804e7ff47fff", + "0x4802804f7ff47ffd", + "0x400280507ff47f63", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307f637ffe7fff", + "0x40307ffc7ff77f64", + "0x482680017ff48000", + "0x51", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x48127f597fff8000", + "0x48127f597fff8000", + "0x480680017fff8000", + "0xbaaedce6af48a03bbfd25e8cd0364141", + "0x480680017fff8000", + "0xfffffffffffffffffffffffffffffffe", + "0x1104800180018000", + "0x1fa", + "0x480680017fff8000", + "0xfffffffffffffffffffffffffffffffe", + "0x48307ffe80017fff", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff97fff", + "0x10780017fff7fff", + "0xc", + "0x400080007ffa7fff", + "0x40780017fff7fff", + "0x1", + "0x482480017ff98000", + "0x1", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x7", + "0x482480017ff98000", + "0x1", + "0x48127ffe7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0xbaaedce6af48a03bbfd25e8cd0364141", + "0x48307ff680017fff", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080007ff97fff", + "0x10780017fff7fff", + "0xc", + "0x400080007ffa7fff", + "0x40780017fff7fff", + "0x5", + "0x482480017ff58000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x10780017fff7fff", + "0x1c", + "0x480680017fff8000", + "0x1", + "0x48307fff80017ff9", + "0xa0680017fff7fff", + "0x7", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400080017ff57fff", + "0x10780017fff7fff", + "0xc", + "0x400080017ff67fff", + "0x40780017fff7fff", + "0x1", + "0x482480017ff58000", + "0x2", + "0x48127ffa7fff8000", + "0x48127ffc7fff8000", + "0x48127ff47fff8000", + "0x10780017fff7fff", + "0x8", + "0x482480017ff58000", + "0x2", + "0x48127ffa7fff8000", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x20680017fff7fff", + "0x59", + "0x48127ffc7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x48127e4a7fff8000", + "0x48127e4a7fff8000", + "0x480680017fff8000", + "0xbaaedce6af48a03bbfd25e8cd0364141", + "0x480680017fff8000", + "0xfffffffffffffffffffffffffffffffe", + "0x1104800180018000", + "0x1a6", + "0x48127f017fff8000", + "0x48127f017fff8000", + "0x480680017fff8000", + "0x536563703235366b314d756c", + "0x400080007d497fff", + "0x400080017d497d48", + "0x400080027d497d47", + "0x400080037d497ffd", + "0x400080047d497ffe", + "0x480080067d498000", + "0x20680017fff7fff", + "0x37", + "0x480080057d488000", + "0x480080077d478000", + "0x480680017fff8000", + "0x536563703235366b314d756c", + "0x400080087d457fff", + "0x400080097d457ffd", + "0x4000800a7d457d39", + "0x4000800b7d457ff7", + "0x4000800c7d457ff8", + "0x4800800e7d458000", + "0x20680017fff7fff", + "0x20", + "0x4800800d7d448000", + "0x4800800f7d438000", + "0x480680017fff8000", + "0x536563703235366b31416464", + "0x400080107d417fff", + "0x400080117d417ffd", + "0x400080127d417ffa", + "0x400080137d417ffe", + "0x480080157d418000", + "0x20680017fff7fff", + "0xc", + "0x48127ff17fff8000", + "0x480080147d3f8000", + "0x482480017d3e8000", + "0x17", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x480080167d3b8000", + "0x208b7fff7fff7ffe", + "0x48127ff17fff8000", + "0x480080147d3f8000", + "0x482480017d3e8000", + "0x18", + "0x480680017fff8000", + "0x1", + "0x480080167d3c8000", + "0x480080177d3b8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x4", + "0x48127ff17fff8000", + "0x4800800d7d3f8000", + "0x482480017d3e8000", + "0x11", + "0x480680017fff8000", + "0x1", + "0x4800800f7d3c8000", + "0x480080107d3b8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x8", + "0x48127ff17fff8000", + "0x480080057d3f8000", + "0x482480017d3e8000", + "0x9", + "0x480680017fff8000", + "0x1", + "0x480080077d3c8000", + "0x480080087d3b8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x106", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x753235365f737562204f766572666c6f77", + "0x400080007ffe7fff", + "0x48127ef47fff8000", + "0x48127d3e7fff8000", + "0x48127d3e7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x28f", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480280077ff48001", + "0x480280087ff47ffe", + "0x400280097ff47ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7d5f", + "0x48507d637ffc8000", + "0x48507d627ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4802800a7ff48001", + "0x4802800b7ff47fff", + "0x4002800c7ff47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4802800d7ff47fff", + "0x4802800e7ff47ffd", + "0x4002800f7ff47d52", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307d527ffe7fff", + "0x40307ffc7ff77d5c", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480280107ff48001", + "0x480280117ff47ffe", + "0x400280127ff47ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7d50", + "0x48507d527ffc8000", + "0x48507d517ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480280137ff48001", + "0x480280147ff47fff", + "0x400280157ff47ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480280167ff47fff", + "0x480280177ff47ffd", + "0x400380187ff47ff9", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40287ff97ffe7fff", + "0x40307ffc7ff77d4c", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482680017ff48000", + "0x19", + "0x48127d3e7fff8000", + "0x48127d3e7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x482480017ff98000", + "0x1", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2b9", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x48127d437fff8000", + "0x48127d437fff8000", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x1", + "0x10780017fff7fff", + "0x9", + "0x40780017fff7fff", + "0x2bf", + "0x480080067d3a8000", + "0x482480017d398000", + "0xa", + "0x480080087d388000", + "0x480080097d378000", + "0x480a7ff47fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2c9", + "0x480a7ff47fff8000", + "0x48127d347fff8000", + "0x48127d347fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2cd", + "0x480a7ff47fff8000", + "0x480280057ff68000", + "0x482680017ff68000", + "0x9", + "0x480680017fff8000", + "0x1", + "0x480280077ff68000", + "0x480280087ff68000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x480680017fff8000", + "0x536563703235366b314765745879", + "0x400280007ffc7fff", + "0x400380017ffc7ffa", + "0x400380027ffc7ffd", + "0x480280047ffc8000", + "0x20680017fff7fff", + "0xb5", + "0x480280057ffc8000", + "0x480280067ffc8000", + "0x480280077ffc8000", + "0x480280087ffc8000", + "0x4800800080007ffc", + "0x400080017fff7ffc", + "0x400080027fff7ffd", + "0x400080037fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480a7ff97fff8000", + "0x480280037ffc8000", + "0x480a7ffb7fff8000", + "0x48127ffb7fff8000", + "0x482480017ffa8000", + "0x4", + "0x48127ffa7fff8000", + "0x48127ff97fff8000", + "0x402780017ffc8001", + "0x9", + "0x1104800180018000", + "0x354", + "0x40137ffa7fff8000", + "0x20680017fff7ffb", + "0x8e", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffef61", + "0x20680017fff7ffd", + "0x7b", + "0x480680017fff8000", + "0x4b656363616b", + "0x4002800080017fff", + "0x4002800180017ffb", + "0x4002800280017ffd", + "0x4002800380017ffe", + "0x4802800580018000", + "0x20680017fff7fff", + "0x6a", + "0x4802800780018000", + "0x4002800080007fff", + "0x480680017fff8000", + "0xff00ff00ff00ff00ff00ff00ff00ff", + "0x4002800180007fff", + "0x4802800280008000", + "0x484480017fff8000", + "0xffff", + "0x48307fff7ffc8000", + "0x4002800580007fff", + "0x480680017fff8000", + "0xffff0000ffff0000ffff0000ffff00", + "0x4002800680007fff", + "0x4802800780008000", + "0x484480017fff8000", + "0xffffffff", + "0x48307fff7ffc8000", + "0x4002800a80007fff", + "0x480680017fff8000", + "0xffffffff00000000ffffffff000000", + "0x4002800b80007fff", + "0x4802800c80008000", + "0x484480017fff8000", + "0xffffffffffffffff", + "0x48307fff7ffc8000", + "0x4002800f80007fff", + "0x480680017fff8000", + "0xffffffffffffffff00000000000000", + "0x4002801080007fff", + "0x4802801180008000", + "0x484480017fff8000", + "0xffffffffffffffffffffffffffffffff", + "0x48307fff7ffc8000", + "0x4802800680018000", + "0x4002801480007fff", + "0x480680017fff8000", + "0xff00ff00ff00ff00ff00ff00ff00ff", + "0x4002801580007fff", + "0x4802801680008000", + "0x484480017fff8000", + "0xffff", + "0x48307fff7ffc8000", + "0x4002801980007fff", + "0x480680017fff8000", + "0xffff0000ffff0000ffff0000ffff00", + "0x4002801a80007fff", + "0x4802801b80008000", + "0x484480017fff8000", + "0xffffffff", + "0x48307fff7ffc8000", + "0x4002801e80007fff", + "0x480680017fff8000", + "0xffffffff00000000ffffffff000000", + "0x4002801f80007fff", + "0x4802802080008000", + "0x484480017fff8000", + "0xffffffffffffffff", + "0x48307fff7ffc8000", + "0x4002802380007fff", + "0x480680017fff8000", + "0xffffffffffffffff00000000000000", + "0x4002802480007fff", + "0x4802802580008000", + "0x484480017fff8000", + "0xffffffffffffffffffffffffffffffff", + "0x48307fff7ffc8000", + "0x484480017fff8000", + "0x800000000000010fffffffffffffff7ffffffffffffef000000000000000001", + "0x480680017fff8000", + "0x100000000", + "0x480080007fd58005", + "0x480080017fd48005", + "0x4824800180047ffe", + "0x1", + "0x48307ffd7ffe7ffc", + "0x480080027fd17ffd", + "0xa0680017fff7ffd", + "0x6", + "0x482480017ff97ffd", + "0xffffffffffffffff0000000000000000", + "0x10780017fff7fff", + "0x4", + "0x482480017fff7ffd", + "0xffffffffffffffff0000000000000000", + "0x400080037fce7ffc", + "0x40507ffe7ff87ffd", + "0x40307fff7ffd7ff7", + "0x484480017fff8000", + "0x100000000000000000000000000000000", + "0x484480017fe48000", + "0x800000000000010fffffffffffffff7ffffffffffffef000000000000000001", + "0x482480017fcc8000", + "0x4", + "0x4802800480018000", + "0x4826800180008000", + "0x28", + "0x4826800180018000", + "0x8", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48307ff97ff88000", + "0x208b7fff7fff7ffe", + "0x48127ff97fff8000", + "0x4802800480018000", + "0x4826800180018000", + "0x8", + "0x4802800680018000", + "0x4802800780018000", + "0x10780017fff7fff", + "0xe", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a80017fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x10780017fff7fff", + "0x7", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a80017fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x480a80007fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff97fff8000", + "0x480280037ffc8000", + "0x480a7ffb7fff8000", + "0x482680017ffc8000", + "0x7", + "0x480680017fff8000", + "0x1", + "0x480280057ffc8000", + "0x480280067ffc8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480280007ff78001", + "0x480280017ff77ffe", + "0x400280027ff77ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40317ffc7fff7ff8", + "0x48487ffa7ffc8000", + "0x48487ffa7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480280037ff78001", + "0x480280047ff77fff", + "0x400280057ff77ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480280067ff77fff", + "0x480280077ff77ffd", + "0x400280087ff77ff0", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307ff07ffe7fff", + "0x40307ffc7ff77fef", + "0x40780017fff7fff", + "0x2", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480280097ff78001", + "0x4802800a7ff77ffe", + "0x4002800b7ff77ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40317ffc7fff7ff8", + "0x48487ffb7ffc8000", + "0x48487ffb7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4802800c7ff78001", + "0x4802800d7ff77fff", + "0x4002800e7ff77ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4802800f7ff77fff", + "0x480280107ff77ffd", + "0x400280117ff77ff0", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307ff07ffe7fff", + "0x40307ffc7ff77fef", + "0x48307ff07fde8001", + "0xa0680017fff7fff", + "0x7", + "0x4824800180007fff", + "0x100000000000000000000000000000000", + "0x400280127ff77fff", + "0x10780017fff7fff", + "0xc", + "0x400280127ff77fff", + "0x40780017fff7fff", + "0x1", + "0x482680017ff78000", + "0x13", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x7", + "0x482680017ff78000", + "0x13", + "0x48127ffe7fff8000", + "0x480680017fff8000", + "0x1", + "0x40780017fff7fff", + "0x2", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080007ffa8001", + "0x480080017ff97ffe", + "0x400080027ff87ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40317ffc7fff7ff9", + "0x48487ffa7ffc8000", + "0x48487ffa7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080037ff48001", + "0x480080047ff37fff", + "0x400080057ff27ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480080067fee7fff", + "0x480080077fed7ffd", + "0x400080087fec7ff0", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307ff07ffe7fff", + "0x40307ffc7ff77fef", + "0x48307ff07fed8001", + "0xa0680017fff7fff", + "0x7", + "0x4824800180007fff", + "0x100000000000000000000000000000000", + "0x400080097fe97fff", + "0x10780017fff7fff", + "0xc", + "0x400080097fea7fff", + "0x40780017fff7fff", + "0x1", + "0x482480017fe98000", + "0xa", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x7", + "0x482480017fe98000", + "0xa", + "0x48127ffe7fff8000", + "0x480680017fff8000", + "0x1", + "0x48307fe97fd28001", + "0xa0680017fff7fff", + "0x7", + "0x4824800180007fff", + "0x100000000000000000000000000000000", + "0x400080007ffa7fff", + "0x10780017fff7fff", + "0xc", + "0x400080007ffb7fff", + "0x40780017fff7fff", + "0x1", + "0x482480017ffa8000", + "0x1", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x7", + "0x482480017ffa8000", + "0x1", + "0x48127ffe7fff8000", + "0x480680017fff8000", + "0x1", + "0x40780017fff7fff", + "0x2", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080007ffa8001", + "0x480080017ff97ffe", + "0x400080027ff87ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40317ffc7fff7ff9", + "0x48487ffb7ffc8000", + "0x48487ffb7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080037ff48001", + "0x480080047ff37fff", + "0x400080057ff27ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480080067fee7fff", + "0x480080077fed7ffd", + "0x400080087fec7ff0", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307ff07ffe7fff", + "0x40307ffc7ff77fef", + "0x48307fee7fef8001", + "0xa0680017fff7fff", + "0x7", + "0x4824800180007fff", + "0x100000000000000000000000000000000", + "0x400080097fe97fff", + "0x10780017fff7fff", + "0xa", + "0x400080097fea7fff", + "0x40780017fff7fff", + "0x1", + "0x482480017fe98000", + "0xa", + "0x48127ffd7fff8000", + "0x10780017fff7fff", + "0x5", + "0x482480017fe98000", + "0xa", + "0x48127ffe7fff8000", + "0x48307feb7fe88001", + "0xa0680017fff7fff", + "0x7", + "0x4824800180007fff", + "0x100000000000000000000000000000000", + "0x400080007ffb7fff", + "0x10780017fff7fff", + "0xc", + "0x400080007ffc7fff", + "0x40780017fff7fff", + "0x1", + "0x482480017ffb8000", + "0x1", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x7", + "0x482480017ffb8000", + "0x1", + "0x48127ffe7fff8000", + "0x480680017fff8000", + "0x1", + "0x48307fff7ff98001", + "0xa0680017fff7fff", + "0x7", + "0x4824800180007fff", + "0x100000000000000000000000000000000", + "0x400080007ffa7fff", + "0x10780017fff7fff", + "0xa", + "0x400080007ffb7fff", + "0x40780017fff7fff", + "0x1", + "0x482480017ffa8000", + "0x1", + "0x48127ffd7fff8000", + "0x10780017fff7fff", + "0x5", + "0x482480017ffa8000", + "0x1", + "0x48127ffe7fff8000", + "0x48307fd87fc18001", + "0xa0680017fff7fff", + "0x7", + "0x4824800180007fff", + "0x100000000000000000000000000000000", + "0x400080007ffb7fff", + "0x10780017fff7fff", + "0xa", + "0x400080007ffc7fff", + "0x40780017fff7fff", + "0x1", + "0x482480017ffb8000", + "0x1", + "0x48127ffd7fff8000", + "0x10780017fff7fff", + "0x5", + "0x482480017ffb8000", + "0x1", + "0x48127ffe7fff8000", + "0x48307fff7ff48001", + "0xa0680017fff7fff", + "0x7", + "0x4824800180007fff", + "0x100000000000000000000000000000000", + "0x400080007ffb7fff", + "0x10780017fff7fff", + "0xc", + "0x400080007ffc7fff", + "0x40780017fff7fff", + "0x1", + "0x482480017ffb8000", + "0x1", + "0x48127ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x10780017fff7fff", + "0x7", + "0x482480017ffb8000", + "0x1", + "0x48127ffe7fff8000", + "0x480680017fff8000", + "0x1", + "0x48307fff7ff48001", + "0xa0680017fff7fff", + "0x7", + "0x4824800180007fff", + "0x100000000000000000000000000000000", + "0x400080007ffa7fff", + "0x10780017fff7fff", + "0xa", + "0x400080007ffb7fff", + "0x40780017fff7fff", + "0x1", + "0x482480017ffa8000", + "0x1", + "0x48127ffd7fff8000", + "0x10780017fff7fff", + "0x5", + "0x482480017ffa8000", + "0x1", + "0x48127ffe7fff8000", + "0x48127f8b7fff8000", + "0x48127fc67fff8000", + "0x48127ff77fff8000", + "0x48127ffc7fff8000", + "0x480080007ffa8000", + "0x480080017ff98000", + "0x480080027ff88000", + "0x480080037ff78000", + "0x480080047ff68000", + "0x480080057ff58000", + "0x48317fff80007ffd", + "0x40780017fff7fff", + "0xc", + "0x20680017fff7ff3", + "0x8", + "0x40317ff17ff47ffc", + "0x402480017ff57ff4", + "0x1", + "0x400080067fe77ff5", + "0x10780017fff7fff", + "0x3", + "0x400080067fe77ff3", + "0x48307ff17ff68000", + "0x48307fe880007fff", + "0x4844800180007fff", + "0x100000000000000000000000000000000", + "0x40507fff7fff7fff", + "0x48307ff47fff8000", + "0x48307ff47fff8000", + "0x48307ff57fff8000", + "0x48307fec7fff8000", + "0x48307fe380007fff", + "0x4844800180007fff", + "0x100000000000000000000000000000000", + "0x400080077fde7fff", + "0x482480017fff8000", + "0xfffffffffffffffffffffffffffffffc", + "0x400080087fdd7fff", + "0x48307fef7ffe8000", + "0x48307ff07fff8000", + "0x48307ff07fff8000", + "0x48307ff17fff8000", + "0x48307fdd80007fff", + "0x4844800180007fff", + "0x100000000000000000000000000000000", + "0x400080097fd77fff", + "0x482480017fff8000", + "0xfffffffffffffffffffffffffffffffc", + "0x4000800a7fd67fff", + "0xa0680017fff7fdf", + "0xc", + "0xa0680017fff8001", + "0x6", + "0x480a7ffd7fff7ffe", + "0x40127fdb7fff7ffe", + "0x10780017fff7fff", + "0x10", + "0x48127fdc7fff7ffe", + "0x400a7ffd7fff7ffe", + "0x10780017fff7fff", + "0xc", + "0x480780017fff7ffd", + "0x0", + "0xa0680017fff8000", + "0x6", + "0x400a7ffc7fff7ffd", + "0x40127fdc7fff7ffe", + "0x10780017fff7fff", + "0x4", + "0x40127fdc7fff7ffd", + "0x400a7ffc7fff7ffe", + "0x482480017ffd8000", + "0xffffffffffffffff0000000000000000", + "0x4000800b7fd27fff", + "0x48507ffd7ffc8000", + "0x48307fe97ff98000", + "0x48307fe67fff8000", + "0x40307ffd7fff7fd4", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x4800800c7fce8001", + "0x4800800d7fcd7ffe", + "0x4000800e7fcc7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7fd3", + "0x48487ffc7ffc8000", + "0x48487ffc7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4800800f7fc88001", + "0x480080107fc77fff", + "0x400080117fc67ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480080127fc27fff", + "0x480080137fc17ffd", + "0x400080147fc07fd7", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fd77ffe7fff", + "0x40307ffc7ff77fd8", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080157fbf8001", + "0x480080167fbe7ffe", + "0x400080177fbd7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7fc3", + "0x48487ffd7ffc8000", + "0x48487ffd7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080187fb98001", + "0x480080197fb87fff", + "0x4000801a7fb77ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4800801b7fb37fff", + "0x4800801c7fb27ffd", + "0x4000801d7fb17fc6", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fc67ffe7fff", + "0x40307ffc7ff77fc7", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x4800801e7fb08001", + "0x4800801f7faf7ffe", + "0x400080207fae7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7fb4", + "0x48487ffc7ffc8000", + "0x48487ffc7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080217faa8001", + "0x480080227fa97fff", + "0x400080237fa87ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480080247fa47fff", + "0x480080257fa37ffd", + "0x400080267fa27fb3", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fb37ffe7fff", + "0x40307ffc7ff77fb4", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080277fa18001", + "0x480080287fa07ffe", + "0x400080297f9f7ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7fa4", + "0x48487ffd7ffc8000", + "0x48487ffd7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x4800802a7f9b8001", + "0x4800802b7f9a7fff", + "0x4000802c7f997ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x4800802d7f957fff", + "0x4800802e7f947ffd", + "0x4000802f7f937fa6", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307fa67ffe7fff", + "0x40307ffc7ff77fa7", + "0x4824800180008002", + "0xffffffffffffffff0000000000000000", + "0x480080307f928001", + "0x480080317f917ffe", + "0x400080327f907ffe", + "0x484480017ffe8000", + "0x10000000000000000", + "0x40307ffc7fff7f95", + "0x48487ffc7ffc8000", + "0x48487ffc7ffc8000", + "0x4824800180018002", + "0xffffffffffffffff0000000000000000", + "0x480080337f8c8001", + "0x480080347f8b7fff", + "0x400080357f8a7ffd", + "0x484480017ffd8000", + "0x10000000000000000", + "0x40307ffd7fff7ffb", + "0x484480017ffd8000", + "0x10000000000000000", + "0x48307fff7ff98003", + "0x482480017fff8000", + "0xfffffffffffffffe0000000000000000", + "0x480080367f867fff", + "0x480080377f857ffd", + "0x400080387f847f93", + "0x404480017ffc7ffe", + "0x100000000000000000000000000000000", + "0x40307f937ffe7fff", + "0x40307ffc7ff77f94", + "0x482480017f848000", + "0x39", + "0x48127f8d7fff8000", + "0x48127f8d7fff8000", + "0x208b7fff7fff7ffe", + "0xa0680017fff8000", + "0x7", + "0x4825800180007ffd", + "0x10", + "0x400280007ffc7fff", + "0x10780017fff7fff", + "0x6f", + "0x482680017ffd8000", + "0xfffffffffffffffffffffffffffffff0", + "0x400280007ffc7fff", + "0x4825800180007ffd", + "0x400000000000008800000000000000000000000000000000000000000000010", + "0x484480017fff8000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffff", + "0x482680017ffc8000", + "0x1", + "0x1137ffe7fff7fff", + "0x10780017fff7fff", + "0x5a", + "0x10780017fff7fff", + "0x54", + "0x10780017fff7fff", + "0x4e", + "0x10780017fff7fff", + "0x48", + "0x10780017fff7fff", + "0x42", + "0x10780017fff7fff", + "0x3c", + "0x10780017fff7fff", + "0x36", + "0x10780017fff7fff", + "0x30", + "0x10780017fff7fff", + "0x2a", + "0x10780017fff7fff", + "0x24", + "0x10780017fff7fff", + "0x1e", + "0x10780017fff7fff", + "0x18", + "0x10780017fff7fff", + "0x12", + "0x10780017fff7fff", + "0xc", + "0x10780017fff7fff", + "0x6", + "0x480680017fff8000", + "0x1", + "0x10780017fff7fff", + "0x3c", + "0x480680017fff8000", + "0x100", + "0x10780017fff7fff", + "0x38", + "0x480680017fff8000", + "0x10000", + "0x10780017fff7fff", + "0x34", + "0x480680017fff8000", + "0x1000000", + "0x10780017fff7fff", + "0x30", + "0x480680017fff8000", + "0x100000000", + "0x10780017fff7fff", + "0x2c", + "0x480680017fff8000", + "0x10000000000", + "0x10780017fff7fff", + "0x28", + "0x480680017fff8000", + "0x1000000000000", + "0x10780017fff7fff", + "0x24", + "0x480680017fff8000", + "0x100000000000000", + "0x10780017fff7fff", + "0x20", + "0x480680017fff8000", + "0x10000000000000000", + "0x10780017fff7fff", + "0x1c", + "0x480680017fff8000", + "0x1000000000000000000", + "0x10780017fff7fff", + "0x18", + "0x480680017fff8000", + "0x100000000000000000000", + "0x10780017fff7fff", + "0x14", + "0x480680017fff8000", + "0x10000000000000000000000", + "0x10780017fff7fff", + "0x10", + "0x480680017fff8000", + "0x1000000000000000000000000", + "0x10780017fff7fff", + "0xc", + "0x480680017fff8000", + "0x100000000000000000000000000", + "0x10780017fff7fff", + "0x8", + "0x480680017fff8000", + "0x10000000000000000000000000000", + "0x10780017fff7fff", + "0x4", + "0x480680017fff8000", + "0x1000000000000000000000000000000", + "0x48127ffe7fff8000", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x6e5f627974657320746f6f20626967", + "0x400080007ffe7fff", + "0x482680017ffc8000", + "0x1", + "0x480680017fff8000", + "0x1", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x1104800180018000", + "0x16c", + "0x482480017fff8000", + "0x16b", + "0x480080007fff8000", + "0x480080017fff8000", + "0x484480017fff8000", + "0x8", + "0x482480017fff8000", + "0x3b06", + "0xa0680017fff8000", + "0x8", + "0x48317ffe80007ff8", + "0x482480017fff8000", + "0x100000000000000000000000000000000", + "0x400280007ff77fff", + "0x10780017fff7fff", + "0x45", + "0x48317ffe80007ff8", + "0x400280007ff77fff", + "0x482680017ff78000", + "0x1", + "0x48297ffa80007ffb", + "0x20680017fff7fff", + "0x4", + "0x10780017fff7fff", + "0xa", + "0x482680017ffa8000", + "0x2", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x0", + "0x480a7ffa7fff8000", + "0x10780017fff7fff", + "0x8", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x20680017fff7ffe", + "0x22", + "0x48127ffa7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480080007ffb8000", + "0x480080017ffa8000", + "0x1104800180018000", + "0x37", + "0x20680017fff7ffd", + "0xc", + "0x48127ffb7fff8000", + "0x48127fa87fff8000", + "0x48127ffa7fff8000", + "0x48127fa97fff8000", + "0x48127fa97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc5", + "0x208b7fff7fff7ffe", + "0x48127ffb7fff8000", + "0x48127fa87fff8000", + "0x48127ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffa7fff8000", + "0x48127ff87fff8000", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x48127ff87fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7574206f6620676173", + "0x400080007ffe7fff", + "0x482680017ff78000", + "0x1", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480680017fff8000", + "0x1", + "0x480680017fff8000", + "0x0", + "0x480680017fff8000", + "0x0", + "0x48127ff87fff8000", + "0x482480017ff78000", + "0x1", + "0x208b7fff7fff7ffe", + "0x400380007ff97ffd", + "0x480680017fff8000", + "0xff00ff00ff00ff00ff00ff00ff00ff", + "0x400280017ff97fff", + "0x480280027ff98000", + "0x484480017fff8000", + "0xffff", + "0x48327fff7ffd8000", + "0x400280057ff97fff", + "0x480680017fff8000", + "0xffff0000ffff0000ffff0000ffff00", + "0x400280067ff97fff", + "0x480280077ff98000", + "0x484480017fff8000", + "0xffffffff", + "0x48307fff7ffc8000", + "0x4002800a7ff97fff", + "0x480680017fff8000", + "0xffffffff00000000ffffffff000000", + "0x4002800b7ff97fff", + "0x4802800c7ff98000", + "0x484480017fff8000", + "0xffffffffffffffff", + "0x48307fff7ffc8000", + "0x4002800f7ff97fff", + "0x480680017fff8000", + "0xffffffffffffffff00000000000000", + "0x400280107ff97fff", + "0x480280117ff98000", + "0x484480017fff8000", + "0xffffffffffffffffffffffffffffffff", + "0x48307fff7ffc8000", + "0x484480017fff8000", + "0x800000000000010fffffffffffffff7ffffffffffffef000000000000000001", + "0x480680017fff8000", + "0x10000000000000000", + "0x480280007ff88005", + "0x480280017ff88005", + "0x4824800180047ffe", + "0x1", + "0x48307ffd7ffe7ffc", + "0x480280027ff87ffd", + "0xa0680017fff7ffd", + "0x6", + "0x482480017ff97ffd", + "0xffffffffffffffff0000000000000000", + "0x10780017fff7fff", + "0x4", + "0x482480017fff7ffd", + "0xffffffffffffffff0000000000000000", + "0x400280037ff87ffc", + "0x40507ffe7ff87ffd", + "0x40307fff7ffd7ff7", + "0x482680017ff98000", + "0x14", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ffc", + "0x10000000000000000", + "0x400280047ff87fff", + "0x10780017fff7fff", + "0x99", + "0x482480017ffc8000", + "0xffffffffffffffff0000000000000000", + "0x400280047ff87fff", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ffb", + "0x10000000000000000", + "0x400280057ff87fff", + "0x10780017fff7fff", + "0x81", + "0x482480017ffb8000", + "0xffffffffffffffff0000000000000000", + "0x400280057ff87fff", + "0x400280007ffb7ffa", + "0x400280017ffb7ff9", + "0x400180007ffb7ffc", + "0x480680017fff8000", + "0xff00ff00ff00ff00ff00ff00ff00ff", + "0x400080017ffa7fff", + "0x480080027ffa8000", + "0x484480017fff8000", + "0xffff", + "0x48327fff7ffc8000", + "0x400080057ff77fff", + "0x480680017fff8000", + "0xffff0000ffff0000ffff0000ffff00", + "0x400080067ff67fff", + "0x480080077ff68000", + "0x484480017fff8000", + "0xffffffff", + "0x48307fff7ffc8000", + "0x4000800a7ff37fff", + "0x480680017fff8000", + "0xffffffff00000000ffffffff000000", + "0x4000800b7ff27fff", + "0x4800800c7ff28000", + "0x484480017fff8000", + "0xffffffffffffffff", + "0x48307fff7ffc8000", + "0x4000800f7fef7fff", + "0x480680017fff8000", + "0xffffffffffffffff00000000000000", + "0x400080107fee7fff", + "0x480080117fee8000", + "0x484480017fff8000", + "0xffffffffffffffffffffffffffffffff", + "0x48307fff7ffc8000", + "0x484480017fff8000", + "0x800000000000010fffffffffffffff7ffffffffffffef000000000000000001", + "0x480680017fff8000", + "0x10000000000000000", + "0x480280067ff88005", + "0x480280077ff88005", + "0x4824800180047ffe", + "0x1", + "0x48307ffd7ffe7ffc", + "0x480280087ff87ffd", + "0xa0680017fff7ffd", + "0x6", + "0x482480017ff97ffd", + "0xffffffffffffffff0000000000000000", + "0x10780017fff7fff", + "0x4", + "0x482480017fff7ffd", + "0xffffffffffffffff0000000000000000", + "0x400280097ff87ffc", + "0x40507ffe7ff87ffd", + "0x40307fff7ffd7ff7", + "0x480a7ffa7fff8000", + "0x482680017ffb8000", + "0x2", + "0x482480017fe08000", + "0x14", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ffa", + "0x10000000000000000", + "0x4002800a7ff87fff", + "0x10780017fff7fff", + "0x28", + "0x482480017ffa8000", + "0xffffffffffffffff0000000000000000", + "0x4002800a7ff87fff", + "0xa0680017fff8000", + "0x7", + "0x4824800180007ff9", + "0x10000000000000000", + "0x4002800b7ff87fff", + "0x10780017fff7fff", + "0x12", + "0x482480017ff98000", + "0xffffffffffffffff0000000000000000", + "0x4002800b7ff87fff", + "0x40780017fff7fff", + "0x5", + "0x400080007ff57ff3", + "0x400080017ff57ff2", + "0x482680017ff88000", + "0xc", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ff17fff8000", + "0x482480017ff18000", + "0x2", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0xc", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0xe", + "0x40780017fff7fff", + "0x2", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0xb", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x48127ffd7fff8000", + "0x48127ff57fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x20", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x6", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x10780017fff7fff", + "0xe", + "0x40780017fff7fff", + "0x22", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x4f7074696f6e3a3a756e77726170206661696c65642e", + "0x400080007ffe7fff", + "0x482680017ff88000", + "0x5", + "0x48127ffd7fff8000", + "0x482480017ffc8000", + "0x1", + "0x48127ffd7fff8000", + "0x48127fd57fff8000", + "0x480680017fff8000", + "0x1", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x208b7fff7fff7ffe", + "0x6a09e667", + "0xbb67ae85", + "0x3c6ef372", + "0xa54ff53a", + "0x510e527f", + "0x9b05688c", + "0x1f83d9ab", + "0x5be0cd19", + "0x208b7fff7fff7ffe", + "0xc", + "0x10", + "0x14", + "0x1c", + "0x10", + "0x18", + "0x0", + "0x4", + "0xc", + "0x0", + "0x8", + "0x10", + "0x18", + "0x14", + "0x0", + "0x18", + "0x1c", + "0x20" + ], + "bytecode_segment_lengths": [ + 241, + 180, + 291, + 562, + 171, + 336, + 178, + 289, + 291, + 301, + 174, + 225, + 111, + 341, + 104, + 104, + 113, + 104, + 181, + 185, + 93, + 139, + 139, + 267, + 224, + 148, + 207, + 111, + 150, + 156, + 128, + 123, + 290, + 161, + 250, + 187, + 92, + 66, + 66, + 126, + 106, + 205, + 1205, + 368, + 72, + 190, + 212, + 83, + 352, + 393, + 335, + 48, + 44, + 195, + 196, + 290, + 290, + 302, + 466, + 33, + 142, + 185, + 80, + 129, + 151, + 89, + 253, + 258, + 97, + 220, + 791, + 31, + 1136, + 66, + 176, + 157, + 83, + 239, + 706, + 199, + 552, + 131, + 104, + 232, + 9, + 19 + ], + "hints": [ + [ + 0, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 33, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 37, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 47, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 83, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 102, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x42fe" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -23 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 125, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 137, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -5 + }, + "b": { + "Immediate": "0x7" + } + } + } + } + } + ] + ], + [ + 140, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 176, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 191, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 212, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 226, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 241, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 258, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 277, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x3e4e" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 291, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 295, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 305, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 326, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 341, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -5 + }, + "b": { + "Immediate": "0x7" + } + } + } + } + } + ] + ], + [ + 344, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 371, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 391, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 406, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 423, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 457, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 461, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 471, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "FP", + "offset": 1 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 524, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 571, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 590, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x28b4" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 612, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 633, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 648, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 662, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 683, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 697, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 714, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x1ca2" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 748, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 8 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 752, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 762, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "FP", + "offset": 8 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 815, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 881, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 7 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 885, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 895, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "FP", + "offset": 7 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 948, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 995, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1014, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x70d0" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1036, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 1050, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -5 + }, + "b": { + "Immediate": "0xa" + } + } + } + } + } + ] + ], + [ + 1053, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1079, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1146, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1161, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1175, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1196, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1210, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1224, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1245, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1259, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1274, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1307, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 1311, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 1321, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1336, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1355, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x9e66" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -18 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1376, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1394, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1416, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1430, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1447, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0xc94" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1481, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": 0 + }, + "b": { + "Immediate": "0x0" + } + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1485, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "scalar": { + "Immediate": "0x8000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": 0 + }, + "y": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 1526, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1591, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1638, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1657, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x87a" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1684, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1702, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1717, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1731, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1752, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1766, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1781, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1815, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -1 + }, + "b": { + "Immediate": "0x0" + } + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1819, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "scalar": { + "Immediate": "0x8000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": 0 + }, + "y": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 1844, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1863, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x1248" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -16 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1882, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 1885, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1908, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1930, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1944, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 1961, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x8d54" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2060, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2079, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x8070" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -42 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2122, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2140, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2155, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2169, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2183, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2197, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2219, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2233, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2250, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2284, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 2288, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 2298, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "FP", + "offset": 1 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2351, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2398, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2417, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x28b4" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2439, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 2460, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2475, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2489, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2510, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2524, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2539, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2572, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 2576, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 2586, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2685, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2704, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x5622" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -38 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2733, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2748, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2762, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2776, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2790, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2811, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2825, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2840, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2873, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 2877, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 2887, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2902, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2921, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x128e" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -18 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2940, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 2943, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2963, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2985, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 2999, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3016, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3071, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3118, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3137, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x213e" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3158, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 3161, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3181, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3196, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3210, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3224, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3239, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3256, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3276, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x41a" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3288, + [ + { + "AllocFelt252Dict": { + "segment_arena_ptr": { + "Deref": { + "register": "FP", + "offset": -7 + } + } + } + } + ] + ], + [ + 3307, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3318, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3334, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3352, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x460" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3386, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 3390, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 3400, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "FP", + "offset": 1 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3453, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3530, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3549, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x2a94" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -18 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3575, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 3578, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3598, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3613, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3627, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3641, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3662, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3676, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3691, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3708, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3727, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x76ca" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3747, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3765, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3780, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3795, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3812, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3831, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x3c5a" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3851, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3869, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3884, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3899, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3916, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3941, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -10 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3960, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3980, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 3996, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4012, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4029, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4048, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x382d4" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4068, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4086, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4101, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4116, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4175, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4194, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -17 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4211, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4225, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4239, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4254, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4268, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4282, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4297, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4330, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4377, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4396, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4418, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4438, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4453, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4467, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4482, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4499, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4518, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4530, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4545, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4560, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4575, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4613, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4632, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -12 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4652, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4670, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4685, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4699, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4714, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4752, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4771, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -12 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4791, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4809, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4824, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4838, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4853, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4886, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 4890, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 4900, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4957, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4976, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x1de2" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -28 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 4998, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5016, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 5022, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5041, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5056, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5070, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5091, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5105, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5120, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5200, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5225, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -25 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5247, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5267, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5283, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5298, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5313, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5328, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5344, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5367, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5397, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -55 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5420, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5442, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5459, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5475, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5492, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x33e" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5525, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 5529, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 5539, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5560, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5579, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x2c24" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -60 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5591, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5611, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 5614, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5634, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5649, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5670, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5684, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5699, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5716, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5739, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -9 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5758, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5778, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5794, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5810, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5848, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5873, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -15 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5893, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5913, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5929, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5944, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5960, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 5998, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6017, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x1220" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -12 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6029, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6049, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 6052, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6072, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6087, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6101, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6116, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6133, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6164, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -13 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6184, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6208, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6226, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6244, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6261, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6281, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6305, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6335, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6351, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6369, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6403, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 6407, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 6417, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "FP", + "offset": 1 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6470, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6517, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6536, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x602c" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6560, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6578, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6593, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6607, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6628, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6642, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6657, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6716, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6735, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -17 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6747, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6760, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6775, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6789, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6803, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6818, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6872, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 6876, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 6886, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6922, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6941, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x1a5e" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -28 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6964, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 6967, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 6989, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7004, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7025, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7039, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7053, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7068, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7127, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7146, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x1414" + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -17 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7172, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 7175, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7197, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7212, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7226, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7240, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7255, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x942" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -8 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7327, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7347, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x8de" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7399, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7413, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x8de" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7465, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7479, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7495, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -4 + } + } + } + } + ] + ], + [ + 7504, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -4 + }, + "b": { + "Immediate": "0x8" + } + } + } + } + } + ] + ], + [ + 7517, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -4 + }, + "b": { + "Immediate": "0xd" + } + } + } + } + } + ] + ], + [ + 7534, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -4 + }, + "b": { + "Immediate": "0x14" + } + } + } + } + } + ] + ], + [ + 7537, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7605, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x3480" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -10 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7630, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -9 + } + } + } + } + ] + ], + [ + 7638, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -8 + }, + "b": { + "Deref": { + "register": "AP", + "offset": -3 + } + } + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7663, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7696, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7733, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -1 + }, + "b": { + "Immediate": "0x0" + } + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7737, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "scalar": { + "Immediate": "0x8000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": 0 + }, + "y": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 7779, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -1 + }, + "b": { + "Immediate": "0x0" + } + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7783, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "scalar": { + "Immediate": "0x8000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": 0 + }, + "y": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 7824, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 7828, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 7838, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 7962, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 7966, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 7976, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "FP", + "offset": 2 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 8008, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 8010, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 8130, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 8244, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 8246, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 8299, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -1 + }, + "b": { + "Immediate": "0x0" + } + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 8303, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "scalar": { + "Immediate": "0x8000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": 0 + }, + "y": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 8345, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -1 + }, + "b": { + "Immediate": "0x0" + } + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 8349, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "scalar": { + "Immediate": "0x8000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": 0 + }, + "y": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 9127, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -26 + } + } + } + } + ] + ], + [ + 9360, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9374, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9388, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9452, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9466, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9489, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9513, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -8 + } + } + } + } + ] + ], + [ + 9516, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9532, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -8 + }, + "b": { + "Immediate": "0xa" + } + } + } + } + } + ] + ], + [ + 9569, + [ + { + "GetSegmentArenaIndex": { + "dict_end_ptr": { + "Deref": { + "register": "FP", + "offset": -3 + } + }, + "dict_index": { + "register": "FP", + "offset": 0 + } + } + } + ] + ], + [ + 9610, + [ + { + "AllocSegment": { + "dst": { + "register": "FP", + "offset": 3 + } + } + } + ] + ], + [ + 9618, + [ + { + "InitSquashData": { + "dict_accesses": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "ptr_diff": { + "Deref": { + "register": "FP", + "offset": 0 + } + }, + "n_accesses": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "big_keys": { + "register": "FP", + "offset": 2 + }, + "first_key": { + "register": "FP", + "offset": 1 + } + } + } + ] + ], + [ + 9637, + [ + { + "GetCurrentAccessIndex": { + "range_check_ptr": { + "Deref": { + "register": "FP", + "offset": -9 + } + } + } + } + ] + ], + [ + 9650, + [ + { + "ShouldSkipSquashLoop": { + "should_skip_loop": { + "register": "AP", + "offset": -4 + } + } + } + ] + ], + [ + 9652, + [ + { + "GetCurrentAccessDelta": { + "index_delta_minus1": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9663, + [ + { + "ShouldContinueSquashLoop": { + "should_continue": { + "register": "AP", + "offset": -4 + } + } + } + ] + ], + [ + 9677, + [ + { + "GetNextDictKey": { + "next_key": { + "register": "FP", + "offset": 0 + } + } + } + ] + ], + [ + 9696, + [ + { + "AssertLeFindSmallArcs": { + "range_check_ptr": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -4 + }, + "b": { + "Immediate": "0x1" + } + } + }, + "a": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "b": { + "Deref": { + "register": "FP", + "offset": 0 + } + } + } + } + ] + ], + [ + 9708, + [ + { + "AssertLeIsFirstArcExcluded": { + "skip_exclude_a_flag": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9720, + [ + { + "AssertLeIsSecondArcExcluded": { + "skip_exclude_b_minus_a": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9751, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9759, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9790, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -3 + } + } + } + } + ] + ], + [ + 9804, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9824, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9838, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9852, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -9 + } + } + } + } + ] + ], + [ + 9855, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9878, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -4 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9906, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9920, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 9963, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10002, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10062, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -3 + } + } + } + } + ] + ], + [ + 10072, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10103, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -6 + } + } + } + } + ] + ], + [ + 10106, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10130, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -4 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10164, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -14 + } + } + } + } + ] + ], + [ + 10179, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -2 + } + } + } + } + ] + ], + [ + 10225, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10244, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 5 + }, + "remainder": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 10250, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": -3 + } + } + } + ] + ], + [ + 10301, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10332, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10357, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10372, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10414, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -3 + } + } + } + } + ] + ], + [ + 10426, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10456, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -6 + } + } + } + } + ] + ], + [ + 10461, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10484, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -4 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10518, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -14 + } + } + } + } + ] + ], + [ + 10533, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -2 + } + } + } + } + ] + ], + [ + 10581, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10599, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 5 + }, + "remainder": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 10605, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": -3 + } + } + } + ] + ], + [ + 10634, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -22 + } + } + } + } + ] + ], + [ + 10684, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10722, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10749, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10765, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10791, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x3a84" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10805, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 10880, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 10884, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 10894, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -12 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10912, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 10930, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10949, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -12 + } + }, + "rhs": { + "Immediate": "0x800000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 10953, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 10963, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -13 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 10981, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 10999, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11030, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11054, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11068, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11082, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11096, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11111, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11126, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x42e" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11140, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11160, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11174, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x42e" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11204, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11223, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00" + }, + "dst": { + "register": "AP", + "offset": 5 + } + } + } + ] + ], + [ + 11227, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 11238, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 11264, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -6 + } + } + } + } + ] + ], + [ + 11279, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -6 + }, + "b": { + "Immediate": "0x7" + } + } + } + } + } + ] + ], + [ + 11287, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00" + }, + "dst": { + "register": "AP", + "offset": 5 + } + } + } + ] + ], + [ + 11291, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 11302, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 11332, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -6 + }, + "b": { + "Immediate": "0xe" + } + } + } + } + } + ] + ], + [ + 11348, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -6 + }, + "b": { + "Immediate": "0x15" + } + } + } + } + } + ] + ], + [ + 11456, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11458, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 11503, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11505, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 11614, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00" + }, + "dst": { + "register": "AP", + "offset": 5 + } + } + } + ] + ], + [ + 11618, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 11629, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 11655, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -6 + } + } + } + } + ] + ], + [ + 11670, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -6 + }, + "b": { + "Immediate": "0x7" + } + } + } + } + } + ] + ], + [ + 11677, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -6 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11679, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 11700, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11702, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -3 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 11732, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00" + }, + "dst": { + "register": "AP", + "offset": 5 + } + } + } + ] + ], + [ + 11736, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 11747, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 11778, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -20 + } + } + } + } + ] + ], + [ + 11793, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -25 + }, + "b": { + "Immediate": "0x7" + } + } + } + } + } + ] + ], + [ + 11837, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11856, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 11938, + [ + { + "RandomEcPoint": { + "x": { + "register": "AP", + "offset": 4 + }, + "y": { + "register": "AP", + "offset": 5 + } + } + }, + { + "AllocConstantSize": { + "size": { + "Immediate": "0x2" + }, + "dst": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 12002, + [ + { + "RandomEcPoint": { + "x": { + "register": "AP", + "offset": 4 + }, + "y": { + "register": "AP", + "offset": 5 + } + } + }, + { + "AllocConstantSize": { + "size": { + "Immediate": "0x2" + }, + "dst": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 12072, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12098, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -3 + } + } + } + } + ] + ], + [ + 12115, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -3 + }, + "b": { + "Immediate": "0x7" + } + } + } + } + } + ] + ], + [ + 12157, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12174, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12193, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -4 + } + } + } + } + ] + ], + [ + 12203, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00" + }, + "dst": { + "register": "AP", + "offset": 5 + } + } + } + ] + ], + [ + 12207, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 12218, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 12262, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -4 + }, + "b": { + "Immediate": "0x5" + } + } + } + } + } + ] + ], + [ + 12277, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -4 + }, + "b": { + "Immediate": "0xc" + } + } + } + } + } + ] + ], + [ + 12287, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -5 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12302, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -3 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12318, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00" + }, + "dst": { + "register": "AP", + "offset": 5 + } + } + } + ] + ], + [ + 12322, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 12333, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 4 + } + }, + "scalar": { + "Immediate": "0x8000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 12362, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -29 + } + } + } + } + ] + ], + [ + 12378, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -35 + }, + "b": { + "Immediate": "0x7" + } + } + } + } + } + ] + ], + [ + 12420, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12438, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12540, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12615, + [ + { + "EvalCircuit": { + "n_add_mods": { + "Deref": { + "register": "AP", + "offset": -6 + } + }, + "add_mod_builtin": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "n_mul_mods": { + "Deref": { + "register": "AP", + "offset": -4 + } + }, + "mul_mod_builtin": { + "Deref": { + "register": "FP", + "offset": -5 + } + } + } + } + ] + ], + [ + 12672, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12728, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12821, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12842, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12913, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12941, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 12998, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -7 + } + } + } + } + ] + ], + [ + 13003, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13054, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -8 + } + } + } + } + ] + ], + [ + 13075, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13102, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13118, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13154, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -1 + }, + "b": { + "Immediate": "0x0" + } + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13158, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "scalar": { + "Immediate": "0x8000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": 0 + }, + "y": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 13180, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13194, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 13204, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13227, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13248, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13269, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13317, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x1e28" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -8 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13377, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13397, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0xcc6" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13476, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13506, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13526, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x10ae" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13627, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13657, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13677, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x22ce" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13748, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13769, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 13827, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13880, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13893, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 13901, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -6 + }, + "b": { + "Deref": { + "register": "AP", + "offset": -1 + } + } + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13918, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13950, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 13967, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 13983, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -1 + }, + "b": { + "Deref": { + "register": "AP", + "offset": -3 + } + } + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14005, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14062, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -3 + } + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 14071, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14081, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -3 + }, + "b": { + "Deref": { + "register": "AP", + "offset": -9 + } + } + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14103, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14118, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14143, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -2 + }, + "b": { + "Deref": { + "register": "AP", + "offset": -1 + } + } + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14157, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 14174, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14186, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14196, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -6 + }, + "b": { + "Deref": { + "register": "AP", + "offset": -3 + } + } + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14219, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14234, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14249, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14264, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14277, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x32f0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14287, + [ + { + "TestLessThanOrEqualAddress": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -5 + }, + "b": { + "Immediate": "0x10" + } + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14324, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -6 + } + } + } + } + ] + ], + [ + 14357, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14391, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 14413, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 14450, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 14472, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 14548, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14613, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 14637, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 14678, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 14704, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 14748, + [ + { + "U256InvModN": { + "b0": { + "Deref": { + "register": "FP", + "offset": -5 + } + }, + "b1": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "n0": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "n1": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "g0_or_no_inv": { + "register": "AP", + "offset": 0 + }, + "g1_option": { + "register": "AP", + "offset": 1 + }, + "s_or_r0": { + "register": "AP", + "offset": 2 + }, + "s_or_r1": { + "register": "AP", + "offset": 3 + }, + "t_or_k0": { + "register": "AP", + "offset": 4 + }, + "t_or_k1": { + "register": "AP", + "offset": 5 + } + } + } + ] + ], + [ + 14766, + [ + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -22 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -5 + } + }, + "high": { + "register": "AP", + "offset": -14 + }, + "low": { + "register": "AP", + "offset": -15 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -22 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "high": { + "register": "AP", + "offset": -12 + }, + "low": { + "register": "AP", + "offset": -13 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -21 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -5 + } + }, + "high": { + "register": "AP", + "offset": -10 + }, + "low": { + "register": "AP", + "offset": -11 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -21 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "high": { + "register": "AP", + "offset": -8 + }, + "low": { + "register": "AP", + "offset": -9 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -26 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -20 + } + }, + "high": { + "register": "AP", + "offset": -6 + }, + "low": { + "register": "AP", + "offset": -7 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -26 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -19 + } + }, + "high": { + "register": "AP", + "offset": -4 + }, + "low": { + "register": "AP", + "offset": -5 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -25 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -20 + } + }, + "high": { + "register": "AP", + "offset": -2 + }, + "low": { + "register": "AP", + "offset": -3 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -25 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -19 + } + }, + "high": { + "register": "AP", + "offset": 0 + }, + "low": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 14819, + [ + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -5 + } + }, + "high": { + "register": "AP", + "offset": 0 + }, + "low": { + "register": "FP", + "offset": -5 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -3 + } + }, + "high": { + "register": "AP", + "offset": 1 + }, + "low": { + "register": "AP", + "offset": -9 + } + } + } + ] + ], + [ + 14823, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -10 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 2 + } + } + } + ] + ], + [ + 14837, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14850, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -47 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14860, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 14871, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -35 + } + } + } + ] + ], + [ + 14880, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -62 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14890, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 14901, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -52 + } + } + } + ] + ], + [ + 14910, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -78 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14920, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 14931, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -69 + } + } + } + ] + ], + [ + 14940, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -93 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14950, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 14961, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -86 + } + } + } + ] + ], + [ + 14970, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -103 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 14980, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 14991, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -103 + } + } + } + ] + ], + [ + 15000, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -118 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15010, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 15021, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -120 + } + } + } + ] + ], + [ + 15030, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -134 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15040, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 15051, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -137 + } + } + } + ] + ], + [ + 15060, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -149 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15070, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 15081, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -154 + } + } + } + ] + ], + [ + 15129, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -10 + } + } + } + } + ] + ], + [ + 15146, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -2 + } + } + } + } + ] + ], + [ + 15158, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -6 + }, + "b": { + "Immediate": "0x8" + } + } + } + } + } + ] + ], + [ + 15169, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -10 + }, + "b": { + "Immediate": "0x10" + } + } + } + } + } + ] + ], + [ + 15179, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -14 + }, + "b": { + "Immediate": "0x17" + } + } + } + } + } + ] + ], + [ + 15264, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15293, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -669 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15303, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 15314, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -683 + } + } + } + ] + ], + [ + 15323, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -684 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15333, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 15344, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "FP", + "offset": -5 + } + } + } + ] + ], + [ + 15353, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15422, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -5 + }, + "b": { + "Deref": { + "register": "FP", + "offset": -3 + } + } + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15437, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15456, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15475, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15485, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15487, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 15524, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15543, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15554, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -18 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 5 + }, + "remainder": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 15560, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": -3 + } + } + } + ] + ], + [ + 15574, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15588, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15599, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15628, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15653, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 15657, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x7000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15667, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x1000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15687, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15708, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15729, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15749, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15751, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 15795, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15806, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -16 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 5 + }, + "remainder": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 15812, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": -3 + } + } + } + ] + ], + [ + 15826, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15844, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15857, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15868, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15897, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15922, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 15926, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x7000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 15936, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x1000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15956, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15977, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 15998, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16027, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16029, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 16066, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 16077, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 16088, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 16117, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16142, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 16146, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x7000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 16156, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x1000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16182, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16203, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16225, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16247, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 16258, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 16287, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16312, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 16316, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": 3 + } + }, + "scalar": { + "Immediate": "0x7000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -2 + }, + "y": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 16326, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "scalar": { + "Immediate": "0x1000000000000000000000000000000" + }, + "max_x": { + "Immediate": "0xffffffffffffffffffffffffffffffff" + }, + "x": { + "register": "AP", + "offset": -1 + }, + "y": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16349, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16394, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 16405, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 16434, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16457, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "FP", + "offset": -5 + }, + "b": { + "Deref": { + "register": "FP", + "offset": -3 + } + } + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16481, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16525, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16552, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x8de" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16604, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16661, + [ + { + "TestLessThan": { + "lhs": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -1 + }, + "b": { + "Immediate": "0x0" + } + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16665, + [ + { + "LinearSplit": { + "value": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "scalar": { + "Immediate": "0x8000000000000110000000000000000" + }, + "max_x": { + "Immediate": "0xfffffffffffffffffffffffffffffffe" + }, + "x": { + "register": "AP", + "offset": 0 + }, + "y": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 16707, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16709, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 3 + }, + "remainder": { + "register": "AP", + "offset": 4 + } + } + } + ] + ], + [ + 16796, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 5 + }, + "remainder": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 16802, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": -3 + } + } + } + ] + ], + [ + 16813, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16823, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -3 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16837, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -3 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 5 + }, + "remainder": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 16843, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": -3 + } + } + } + ] + ], + [ + 16857, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -4 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16867, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -5 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16889, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16903, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16921, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16935, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16951, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Immediate": "0x8c0" + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 16978, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 16995, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17020, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17280, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -10 + } + } + } + } + ] + ], + [ + 17306, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -6 + } + } + } + } + ] + ], + [ + 17320, + [ + { + "U256InvModN": { + "b0": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "b1": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "n0": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "n1": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "g0_or_no_inv": { + "register": "AP", + "offset": 0 + }, + "g1_option": { + "register": "AP", + "offset": 1 + }, + "s_or_r0": { + "register": "AP", + "offset": 2 + }, + "s_or_r1": { + "register": "AP", + "offset": 3 + }, + "t_or_k0": { + "register": "AP", + "offset": 4 + }, + "t_or_k1": { + "register": "AP", + "offset": 5 + } + } + } + ] + ], + [ + 17338, + [ + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -22 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "high": { + "register": "AP", + "offset": -14 + }, + "low": { + "register": "AP", + "offset": -15 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -22 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "high": { + "register": "AP", + "offset": -12 + }, + "low": { + "register": "AP", + "offset": -13 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -21 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "high": { + "register": "AP", + "offset": -10 + }, + "low": { + "register": "AP", + "offset": -11 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -21 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "high": { + "register": "AP", + "offset": -8 + }, + "low": { + "register": "AP", + "offset": -9 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -26 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -20 + } + }, + "high": { + "register": "AP", + "offset": -6 + }, + "low": { + "register": "AP", + "offset": -7 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -26 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -19 + } + }, + "high": { + "register": "AP", + "offset": -4 + }, + "low": { + "register": "AP", + "offset": -5 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -25 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -20 + } + }, + "high": { + "register": "AP", + "offset": -2 + }, + "low": { + "register": "AP", + "offset": -3 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -25 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -19 + } + }, + "high": { + "register": "AP", + "offset": 0 + }, + "low": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 17391, + [ + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -5 + } + }, + "high": { + "register": "AP", + "offset": 0 + }, + "low": { + "register": "FP", + "offset": -7 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -7 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -3 + } + }, + "high": { + "register": "AP", + "offset": 1 + }, + "low": { + "register": "AP", + "offset": -9 + } + } + } + ] + ], + [ + 17395, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -10 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 2 + } + } + } + ] + ], + [ + 17409, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -11 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17422, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -47 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17432, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 17443, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -35 + } + } + } + ] + ], + [ + 17452, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -62 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17462, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 17473, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -52 + } + } + } + ] + ], + [ + 17482, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -78 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17492, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 17503, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -69 + } + } + } + ] + ], + [ + 17512, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -93 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17522, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 17533, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -86 + } + } + } + ] + ], + [ + 17542, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -103 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17552, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 17563, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -103 + } + } + } + ] + ], + [ + 17572, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -118 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17582, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 17593, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -120 + } + } + } + ] + ], + [ + 17602, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -134 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17612, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 17623, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -137 + } + } + } + ] + ], + [ + 17632, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -149 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17642, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 17653, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -154 + } + } + } + ] + ], + [ + 17677, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 17702, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 17722, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 17767, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "AP", + "offset": -695 + } + } + } + } + ] + ], + [ + 17779, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -699 + }, + "b": { + "Immediate": "0x8" + } + } + } + } + } + ] + ], + [ + 17790, + [ + { + "SystemCall": { + "system": { + "BinOp": { + "op": "Add", + "a": { + "register": "AP", + "offset": -703 + }, + "b": { + "Immediate": "0x10" + } + } + } + } + } + ] + ], + [ + 17836, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17852, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -669 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17862, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 17873, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -683 + } + } + } + ] + ], + [ + 17882, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -684 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17892, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 17903, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "FP", + "offset": -7 + } + } + } + ] + ], + [ + 17912, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17929, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17986, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": -4 + } + } + } + } + ] + ], + [ + 17993, + [ + { + "AllocConstantSize": { + "size": { + "Immediate": "0x4" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 17997, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18032, + [ + { + "SystemCall": { + "system": { + "Deref": { + "register": "FP", + "offset": 1 + } + } + } + } + ] + ], + [ + 18105, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 5 + }, + "remainder": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 18111, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": -3 + } + } + } + ] + ], + [ + 18178, + [ + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -8 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "high": { + "register": "AP", + "offset": 0 + }, + "low": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18180, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -8 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18190, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18201, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -13 + } + } + } + ] + ], + [ + 18210, + [ + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -8 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -5 + } + }, + "high": { + "register": "AP", + "offset": 0 + }, + "low": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18212, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -8 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18222, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18233, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -13 + } + } + } + ] + ], + [ + 18243, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 18265, + [ + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -6 + } + }, + "high": { + "register": "AP", + "offset": 0 + }, + "low": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18267, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18277, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18288, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -13 + } + } + } + ] + ], + [ + 18298, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 18321, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 18343, + [ + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -5 + } + }, + "high": { + "register": "AP", + "offset": 0 + }, + "low": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18345, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -7 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18355, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18366, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -13 + } + } + } + ] + ], + [ + 18376, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 18395, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 18418, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 18437, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 18456, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 18479, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "dst": { + "register": "AP", + "offset": -1 + } + } + } + ] + ], + [ + 18501, + [ + { + "Uint512DivModByUint256": { + "dividend0": { + "Deref": { + "register": "AP", + "offset": -4 + } + }, + "dividend1": { + "Deref": { + "register": "AP", + "offset": -3 + } + }, + "dividend2": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "dividend3": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "divisor0": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "divisor1": { + "Deref": { + "register": "FP", + "offset": -3 + } + }, + "quotient0": { + "register": "AP", + "offset": 0 + }, + "quotient1": { + "register": "AP", + "offset": 1 + }, + "quotient2": { + "register": "AP", + "offset": 2 + }, + "quotient3": { + "register": "AP", + "offset": 3 + }, + "remainder0": { + "register": "AP", + "offset": 4 + }, + "remainder1": { + "register": "AP", + "offset": 5 + } + } + } + ] + ], + [ + 18519, + [ + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -19 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "high": { + "register": "AP", + "offset": -9 + }, + "low": { + "register": "AP", + "offset": -10 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -18 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "high": { + "register": "AP", + "offset": -7 + }, + "low": { + "register": "AP", + "offset": -8 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -19 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -3 + } + }, + "high": { + "register": "AP", + "offset": -5 + }, + "low": { + "register": "AP", + "offset": -6 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -18 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -3 + } + }, + "high": { + "register": "AP", + "offset": -3 + }, + "low": { + "register": "AP", + "offset": -4 + } + } + }, + { + "WideMul128": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -17 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "high": { + "register": "AP", + "offset": -1 + }, + "low": { + "register": "AP", + "offset": -2 + } + } + } + ] + ], + [ + 18548, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -35 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -3 + } + }, + "dst": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18560, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -35 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -4 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18575, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -41 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18585, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18596, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -38 + } + } + } + ] + ], + [ + 18605, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -57 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18615, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18626, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -55 + } + } + } + ] + ], + [ + 18635, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -72 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18645, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18656, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -74 + } + } + } + ] + ], + [ + 18665, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -88 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18675, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18686, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -87 + } + } + } + ] + ], + [ + 18695, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -103 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 1 + }, + "remainder": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18705, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "quotient": { + "register": "AP", + "offset": 0 + }, + "remainder": { + "register": "AP", + "offset": 1 + } + } + } + ] + ], + [ + 18716, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 2 + } + }, + "rhs": { + "Immediate": "0x100000000000000000000000000000000" + }, + "quotient": { + "register": "AP", + "offset": -1 + }, + "remainder": { + "register": "AP", + "offset": -106 + } + } + } + ] + ], + [ + 18730, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "FP", + "offset": -3 + } + }, + "rhs": { + "Immediate": "0x10" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18848, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18871, + [ + { + "TestLessThanOrEqual": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "rhs": { + "Deref": { + "register": "FP", + "offset": -8 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 18946, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 19001, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 5 + }, + "remainder": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 19007, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": -3 + } + } + } + ] + ], + [ + 19020, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -3 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 19030, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -4 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 19078, + [ + { + "DivMod": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "quotient": { + "register": "AP", + "offset": 5 + }, + "remainder": { + "register": "AP", + "offset": 6 + } + } + } + ] + ], + [ + 19084, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": 0 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": -3 + } + } + } + ] + ], + [ + 19100, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -5 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 19110, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -6 + } + }, + "rhs": { + "Immediate": "0x10000000000000000" + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 19133, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 19147, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 19166, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 19180, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ] + ], + "entry_points_by_type": { + "EXTERNAL": [ + { + "selector": "0x1143aa89c8e3ebf8ed14df2a3606c1cd2dd513fac8040b0f8ab441f5c52fe4", + "offset": 4714, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x3541591104188daef4379e06e92ecce09094a3b381da2e654eb041d00566d8", + "offset": 6244, + "builtins": [ + "range_check", + "range_check96" + ] + }, + { + "selector": "0x3c118a68e16e12e97ed25cb4901c12f4d3162818669cc44c391d8049924c14", + "offset": 1959, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x5562b3e932b4d139366854d5a2e578382e6a3b6572ac9943d55e7efbe43d00", + "offset": 4116, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x600c98a299d72ef1e09a2e1503206fbc76081233172c65f7e2438ef0069d8d", + "offset": 4853, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x62c83572d28cb834a3de3c1e94977a4191469a4a8c26d1d7bc55305e640ed5", + "offset": 4297, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x679c22735055a10db4f275395763a3752a1e3a3043c192299ab6b574fba8d6", + "offset": 5699, + "builtins": [ + "range_check", + "ec_op" + ] + }, + { + "selector": "0x7772be8b80a8a33dc6c1f9a6ab820c02e537c73e859de67f288c70f92571bb", + "offset": 5344, + "builtins": [ + "pedersen", + "range_check", + "bitwise" + ] + }, + { + "selector": "0xd47144c49bce05b6de6bce9d5ff0cc8da9420f8945453e20ef779cbea13ad4", + "offset": 241, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0xe7510edcf6e9f1b70f7bd1f488767b50f0363422f3c563160ab77adf62467b", + "offset": 2840, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0xf818e4530ec36b83dfe702489b4df537308c3b798b0cc120e32c2056d68b7d", + "offset": 3691, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x10d2fede95e3ec06a875a67219425c27c5bd734d57f1b221d729a2337b6b556", + "offset": 3239, + "builtins": [ + "range_check", + "segment_arena" + ] + }, + { + "selector": "0x12ead94ae9d3f9d2bdb6b847cf255f1f398193a1f88884a0ae8e18f24a037b6", + "offset": 5960, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x14dae1999ae9ab799bc72def6dc6e90890cf8ac0d64525021b7e71d05cb13e8", + "offset": 1445, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x169f135eddda5ab51886052d777a57f2ea9c162d713691b5e04a6d4ed71d47f", + "offset": 3350, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x1ae1a515cf2d214b29bdf63a79ee2d490efd4dd1acc99d383a8e549c3cecb5d", + "offset": 5810, + "builtins": [ + "pedersen", + "range_check" + ] + }, + { + "selector": "0x1e4089d1f1349077b1970f9937c904e27c4582b49a60b6078946dba95bc3c08", + "offset": 1274, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x23039bef544cff56442d9f61ae9b13cf9e36fcce009102c5b678aac93f37b36", + "offset": 1781, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x27c3334165536f239cfd400ed956eabff55fc60de4fb56728b6a4f6b87db01c", + "offset": 421, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x298e03955860424b6a946506da72353a645f653dc1879f6b55fd756f3d20a59", + "offset": 712, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x2d7cf5d5a324a320f9f37804b1615a533fde487400b41af80f13f7ac5581325", + "offset": 3014, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x30f842021fbf02caf80d09a113997c1e00a32870eee0c6136bed27acb348bea", + "offset": 5492, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x31401f504973a5e8e1bb41e9c592519e3aa0b8cf6bbfb9c91b532aab8db54b0", + "offset": 6367, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x317eb442b72a9fae758d4fb26830ed0d9f31c8e7da4dbff4e8c59ea6a158e7f", + "offset": 5120, + "builtins": [ + "pedersen", + "range_check" + ] + }, + { + "selector": "0x32564d7e0fe091d49b4c20f4632191e4ed6986bf993849879abfef9465def25", + "offset": 4482, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x3604cea1cdb094a73a31144f14a3e5861613c008e1e879939ebc4827d10cd50", + "offset": 2248, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x382be990ca34815134e64a9ac28f41a907c62e5ad10547f97174362ab94dc89", + "offset": 3795, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x38be5d5f7bf135b52888ba3e440a457d11107aca3f6542e574b016bf3f074d8", + "offset": 3899, + "builtins": [ + "range_check", + "bitwise" + ] + }, + { + "selector": "0x3a6a8bae4c51d5959683ae246347ffdd96aa5b2bfa68cc8c3a6a7c2ed0be331", + "offset": 2539, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x3b097c62d3e4b85742aadd0dfb823f96134b886ec13bda57b68faf86f294d97", + "offset": 0, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x3d3da80997f8be5d16e9ae7ee6a4b5f7191d60765a1a6c219ab74269c85cf97", + "offset": 6116, + "builtins": [ + "range_check", + "range_check96", + "add_mod", + "mul_mod" + ] + }, + { + "selector": "0x3d95049b565ec2d4197a55108ef03996381d31c84acf392a0a42b28163d69d1", + "offset": 4012, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x3eb640b15f75fcc06d43182cdb94ed38c8e71755d5fb57c16dd673b466db1d4", + "offset": 4575, + "builtins": [ + "range_check" + ] + } + ], + "L1_HANDLER": [ + { + "selector": "0x205500a208d0d49d79197fea83cc3f5fde99ac2e1909ae0a5d9f394c0c52ed0", + "offset": 6818, + "builtins": [ + "range_check" + ] + }, + { + "selector": "0x39edbbb129ad752107a94d40c3873cae369a46fd2fc578d075679aa67e85d12", + "offset": 6657, + "builtins": [ + "range_check" + ] + } + ], + "CONSTRUCTOR": [ + { + "selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194", + "offset": 7068, + "builtins": [ + "range_check" + ] + } + ] + } +} diff --git a/crates/blockifier/src/test_utils/contracts.rs b/crates/blockifier/src/test_utils/contracts.rs index e90ce9d4432..a177ae719b4 100644 --- a/crates/blockifier/src/test_utils/contracts.rs +++ b/crates/blockifier/src/test_utils/contracts.rs @@ -53,6 +53,7 @@ const LEGACY_CONTRACT_BASE: u32 = 5 * CLASS_HASH_BASE; const SECURITY_TEST_CONTRACT_BASE: u32 = 6 * CLASS_HASH_BASE; const TEST_CONTRACT_BASE: u32 = 7 * CLASS_HASH_BASE; const ERC20_CONTRACT_BASE: u32 = 8 * CLASS_HASH_BASE; +const CAIRO_STEPS_TEST_CONTRACT_BASE: u32 = 9 * CLASS_HASH_BASE; // Contract names. const ACCOUNT_LONG_VALIDATE_NAME: &str = "account_with_long_validate"; @@ -62,6 +63,7 @@ const FAULTY_ACCOUNT_NAME: &str = "account_faulty"; const LEGACY_CONTRACT_NAME: &str = "legacy_test_contract"; const SECURITY_TEST_CONTRACT_NAME: &str = "security_tests_contract"; const TEST_CONTRACT_NAME: &str = "test_contract"; +const CAIRO_STEPS_TEST_CONTRACT_NAME: &str = "cairo_steps_test_contract"; // ERC20 contract is in a unique location. const ERC20_CAIRO0_CONTRACT_SOURCE_PATH: &str = @@ -71,11 +73,14 @@ const ERC20_CAIRO0_CONTRACT_PATH: &str = "./ERC20/ERC20_Cairo0/ERC20_without_som const ERC20_CAIRO1_CONTRACT_SOURCE_PATH: &str = "./ERC20/ERC20_Cairo1/ERC20.cairo"; const ERC20_CAIRO1_CONTRACT_PATH: &str = "./ERC20/ERC20_Cairo1/erc20.casm.json"; -// Legacy contract is compiled with a fixed version of the compiler. This compiler version no longer -// compiles with stable rust, so the toolchain is also fixed. +// The following contracts are compiled with a fixed version of the compiler. This compiler version +// no longer compiles with stable rust, so the toolchain is also fixed. const LEGACY_CONTRACT_COMPILER_TAG: &str = "v2.1.0"; const LEGACY_CONTRACT_RUST_TOOLCHAIN: &str = "2023-07-05"; +const CAIRO_STEPS_TEST_CONTRACT_COMPILER_TAG: &str = "v2.7.0"; +const CAIRO_STEPS_TEST_CONTRACT_RUST_TOOLCHAIN: &str = "2024-04-29"; + /// Enum representing all feature contracts. /// The contracts that are implemented in both Cairo versions include a version field. #[derive(Clone, Copy, Debug, EnumIter, Hash, PartialEq, Eq)] @@ -88,6 +93,7 @@ pub enum FeatureContract { LegacyTestContract, SecurityTests, TestContract(CairoVersion), + CairoStepsTestContract, } impl FeatureContract { @@ -100,7 +106,7 @@ impl FeatureContract { | Self::TestContract(version) | Self::ERC20(version) => *version, Self::SecurityTests => CairoVersion::Cairo0, - Self::LegacyTestContract => CairoVersion::Cairo1, + Self::LegacyTestContract | Self::CairoStepsTestContract => CairoVersion::Cairo1, } } @@ -112,7 +118,7 @@ impl FeatureContract { | Self::FaultyAccount(_) | Self::TestContract(_) | Self::ERC20(_) => true, - Self::SecurityTests | Self::LegacyTestContract => false, + Self::SecurityTests | Self::LegacyTestContract | Self::CairoStepsTestContract => false, } } @@ -124,7 +130,7 @@ impl FeatureContract { | Self::FaultyAccount(v) | Self::TestContract(v) | Self::ERC20(v) => *v = version, - Self::LegacyTestContract | Self::SecurityTests => { + Self::LegacyTestContract | Self::SecurityTests | Self::CairoStepsTestContract => { panic!("{self:?} contract has no configurable version.") } } @@ -180,8 +186,21 @@ impl FeatureContract { } } - pub fn is_legacy(&self) -> bool { - matches!(self, Self::LegacyTestContract) + /// Some contracts are designed to test behavior of code compiled with a + /// specific (old) compiler tag. To run the (old) compiler, older rust + /// version is required. + pub fn fixed_tag_and_rust_toolchain(&self) -> (Option, Option) { + match self { + Self::LegacyTestContract => ( + Some(LEGACY_CONTRACT_COMPILER_TAG.into()), + Some(LEGACY_CONTRACT_RUST_TOOLCHAIN.into()), + ), + Self::CairoStepsTestContract => ( + Some(CAIRO_STEPS_TEST_CONTRACT_COMPILER_TAG.into()), + Some(CAIRO_STEPS_TEST_CONTRACT_RUST_TOOLCHAIN.into()), + ), + _ => (None, None), + } } /// Unique integer representing each unique contract. Used to derive "class hash" and "address". @@ -196,6 +215,7 @@ impl FeatureContract { Self::LegacyTestContract => LEGACY_CONTRACT_BASE, Self::SecurityTests => SECURITY_TEST_CONTRACT_BASE, Self::TestContract(_) => TEST_CONTRACT_BASE, + Self::CairoStepsTestContract => CAIRO_STEPS_TEST_CONTRACT_BASE, } } @@ -208,6 +228,7 @@ impl FeatureContract { Self::LegacyTestContract => LEGACY_CONTRACT_NAME, Self::SecurityTests => SECURITY_TEST_CONTRACT_NAME, Self::TestContract(_) => TEST_CONTRACT_NAME, + Self::CairoStepsTestContract => CAIRO_STEPS_TEST_CONTRACT_NAME, Self::ERC20(_) => unreachable!(), } } @@ -273,23 +294,14 @@ impl FeatureContract { FeatureContract::SecurityTests => Some("--disable_hint_validation".into()), FeatureContract::Empty(_) | FeatureContract::TestContract(_) - | FeatureContract::LegacyTestContract => None, + | FeatureContract::LegacyTestContract + | FeatureContract::CairoStepsTestContract => None, FeatureContract::ERC20(_) => unreachable!(), }; cairo0_compile(self.get_source_path(), extra_arg, false) } CairoVersion::Cairo1 => { - let (tag_override, cargo_nightly_arg) = if self.is_legacy() { - ( - // Legacy contract is designed to test behavior of code compiled with a - // specific (old) compiler tag. To run the (old) compiler, older rust - // version is required. - Some(LEGACY_CONTRACT_COMPILER_TAG.into()), - Some(LEGACY_CONTRACT_RUST_TOOLCHAIN.into()), - ) - } else { - (None, None) - }; + let (tag_override, cargo_nightly_arg) = self.fixed_tag_and_rust_toolchain(); cairo1_compile(self.get_source_path(), tag_override, cargo_nightly_arg) } } From a8f74878fa1fb32f1a8c32efad6c483cf8fc0c5b Mon Sep 17 00:00:00 2001 From: yoavGrs <97383386+yoavGrs@users.noreply.github.com> Date: Wed, 9 Oct 2024 16:49:40 +0300 Subject: [PATCH 42/57] test(blockifier): track resources for old cairo1 contract (#1272) --- .../syscalls/syscall_tests/call_contract.rs | 29 +++++++++++-------- 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/crates/blockifier/src/execution/syscalls/syscall_tests/call_contract.rs b/crates/blockifier/src/execution/syscalls/syscall_tests/call_contract.rs index 3a519964faa..08add6449a2 100644 --- a/crates/blockifier/src/execution/syscalls/syscall_tests/call_contract.rs +++ b/crates/blockifier/src/execution/syscalls/syscall_tests/call_contract.rs @@ -136,22 +136,27 @@ fn test_track_resources( assert_eq!(execution.inner_calls.first().unwrap().tracked_resource, expected_inner_resource); } -/// Cairo1 contract (root) calls: -/// 1) Cairo0 contract (first) that calls Cairo1 (nested) contract. -/// 2) Cairo1 contract (second). -#[test] -fn test_track_resources_nested() { - let cairo_0_contract = FeatureContract::TestContract(CairoVersion::Cairo0); - let cairo_1_contract = FeatureContract::TestContract(CairoVersion::Cairo1); +/// Sierra-Gas contract calls: +/// 1) Cairo-Steps contract that calls Sierra-Gas (nested) contract. +/// 2) Sierra-Gas contract. +#[rstest] +fn test_track_resources_nested( + #[values( + FeatureContract::TestContract(CairoVersion::Cairo0), + FeatureContract::CairoStepsTestContract + )] + cairo_steps_contract: FeatureContract, +) { + let sierra_gas_contract = FeatureContract::TestContract(CairoVersion::Cairo1); let chain_info = &ChainInfo::create_for_testing(); let mut state = - test_state(chain_info, BALANCE, &[(cairo_1_contract, 1), (cairo_0_contract, 1)]); + test_state(chain_info, BALANCE, &[(sierra_gas_contract, 1), (cairo_steps_contract, 1)]); let first_calldata = create_calldata( - cairo_0_contract.get_instance_address(0), + cairo_steps_contract.get_instance_address(0), "test_call_contract", &[ - cairo_1_contract.get_instance_address(0).into(), + sierra_gas_contract.get_instance_address(0).into(), selector_from_name("test_storage_read_write").0, felt!(2_u8), // Calldata length felt!(405_u16), // Calldata: address. @@ -159,7 +164,7 @@ fn test_track_resources_nested() { ], ); let second_calldata = create_calldata( - cairo_1_contract.get_instance_address(0), + sierra_gas_contract.get_instance_address(0), "test_storage_read_write", &[ felt!(406_u16), // Calldata: address. @@ -176,7 +181,7 @@ fn test_track_resources_nested() { let entry_point_call = CallEntryPoint { entry_point_selector: call_contract_selector, calldata: concated_calldata, - ..trivial_external_entry_point_new(cairo_1_contract) + ..trivial_external_entry_point_new(sierra_gas_contract) }; let execution = entry_point_call.execute_directly(&mut state).unwrap(); From 64d981ba58b4a3578dcb22c7e1ead063c6d6d4f5 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Wed, 9 Oct 2024 17:33:13 +0300 Subject: [PATCH 43/57] fix(blockifier): gas amounts / gas prices in error formatting (#1284) Signed-off-by: Dori Medini --- crates/blockifier/src/transaction/errors.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/crates/blockifier/src/transaction/errors.rs b/crates/blockifier/src/transaction/errors.rs index 81f02f14e17..8c40e73a3ab 100644 --- a/crates/blockifier/src/transaction/errors.rs +++ b/crates/blockifier/src/transaction/errors.rs @@ -28,10 +28,10 @@ pub enum TransactionFeeError { #[error("Actual fee ({}) exceeded paid fee on L1 ({}).", actual_fee.0, paid_fee.0)] InsufficientFee { paid_fee: Fee, actual_fee: Fee }, #[error( - "Resources bounds (l1 gas max amount: {l1_max_amount:?}, l1 gas max price: \ - {l1_max_price:?}, l1 data max amount: {l1_data_max_amount:?}, l1 data max price: \ - {l1_data_max_price:?}, l2 gas max amount: {l2_max_amount:?}, l2 gas max price: \ - {l2_max_price:?}) exceed balance ({balance})." + "Resources bounds (l1 gas max amount: {l1_max_amount}, l1 gas max price: {l1_max_price}, \ + l1 data max amount: {l1_data_max_amount}, l1 data max price: {l1_data_max_price}, l2 gas \ + max amount: {l2_max_amount}, l2 gas max price: {l2_max_price}) exceed balance \ + ({balance})." )] ResourcesBoundsExceedBalance { l1_max_amount: GasAmount, @@ -43,8 +43,8 @@ pub enum TransactionFeeError { balance: BigUint, }, #[error( - "Resource {resource} bounds (max amount: {max_amount:?}, max price): {max_price:?}) \ - exceed balance ({balance})." + "Resource {resource} bounds (max amount: {max_amount}, max price): {max_price}) exceed \ + balance ({balance})." )] GasBoundsExceedBalance { resource: Resource, From fe199373144f7e77761f559f3a9d7ca591571574 Mon Sep 17 00:00:00 2001 From: Ayelet Zilber <138376632+ayeletstarkware@users.noreply.github.com> Date: Thu, 10 Oct 2024 09:40:55 +0300 Subject: [PATCH 44/57] chore(batcher): add derives to ExecutionConfig and related structs for addition to BatcherConfig (#1274) --- crates/batcher/src/block_builder.rs | 3 ++- crates/blockifier/src/blockifier/config.rs | 6 ++++-- crates/blockifier/src/bouncer.rs | 2 +- crates/blockifier/src/versioned_constants.rs | 4 ++-- 4 files changed, 9 insertions(+), 6 deletions(-) diff --git a/crates/batcher/src/block_builder.rs b/crates/batcher/src/block_builder.rs index e9a959641c7..3e2d3256957 100644 --- a/crates/batcher/src/block_builder.rs +++ b/crates/batcher/src/block_builder.rs @@ -19,6 +19,7 @@ use indexmap::IndexMap; #[cfg(test)] use mockall::automock; use papyrus_storage::StorageReader; +use serde::{Deserialize, Serialize}; use starknet_api::block::{BlockNumber, BlockTimestamp, NonzeroGasPrice}; use starknet_api::core::ContractAddress; use starknet_api::executable_transaction::Transaction; @@ -44,7 +45,7 @@ pub enum BlockBuilderError { pub type BlockBuilderResult = Result; -#[derive(Clone)] +#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)] pub struct ExecutionConfig { // TODO(Yael 1/10/2024): add to config pointers pub chain_info: ChainInfo, diff --git a/crates/blockifier/src/blockifier/config.rs b/crates/blockifier/src/blockifier/config.rs index 8f461aab88d..25781aaa422 100644 --- a/crates/blockifier/src/blockifier/config.rs +++ b/crates/blockifier/src/blockifier/config.rs @@ -1,4 +1,6 @@ -#[derive(Debug, Default, Clone)] +use serde::{Deserialize, Serialize}; + +#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)] pub struct TransactionExecutorConfig { pub concurrency_config: ConcurrencyConfig, } @@ -9,7 +11,7 @@ impl TransactionExecutorConfig { } } -#[derive(Debug, Default, Clone)] +#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)] pub struct ConcurrencyConfig { pub enabled: bool, pub n_workers: usize, diff --git a/crates/blockifier/src/bouncer.rs b/crates/blockifier/src/bouncer.rs index 943d78ac2ed..1508eeea315 100644 --- a/crates/blockifier/src/bouncer.rs +++ b/crates/blockifier/src/bouncer.rs @@ -38,7 +38,7 @@ macro_rules! impl_checked_sub { pub type HashMapWrapper = HashMap; -#[derive(Clone, Debug, Default, PartialEq)] +#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)] pub struct BouncerConfig { pub block_max_capacity: BouncerWeights, } diff --git a/crates/blockifier/src/versioned_constants.rs b/crates/blockifier/src/versioned_constants.rs index 48ccc7281c3..4655d32c1de 100644 --- a/crates/blockifier/src/versioned_constants.rs +++ b/crates/blockifier/src/versioned_constants.rs @@ -11,7 +11,7 @@ use num_traits::Inv; use paste::paste; use semver::Version; use serde::de::Error as DeserializationError; -use serde::{Deserialize, Deserializer}; +use serde::{Deserialize, Deserializer, Serialize}; use serde_json::{Map, Number, Value}; use starknet_api::block::GasPrice; use starknet_api::execution_resources::GasAmount; @@ -853,7 +853,7 @@ pub struct ResourcesByVersion { pub deprecated_resources: ResourcesParams, } -#[derive(Clone)] +#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)] pub struct VersionedConstantsOverrides { pub validate_max_n_steps: u32, pub max_recursion_depth: usize, From 72a16a716baf5af5eee8377e149c29ac9cf7b400 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Thu, 10 Oct 2024 10:54:46 +0300 Subject: [PATCH 45/57] test(blockifier): fix grindy-validate test to use tighter bounds (#1212) Signed-off-by: Dori Medini --- .../cairo0/account_with_long_validate.cairo | 2 +- .../account_with_long_validate_compiled.json | 19 +- .../cairo1/account_with_long_validate.cairo | 2 +- .../account_with_long_validate.casm.json | 190 ++++++++++++------ .../transaction/account_transactions_test.rs | 8 +- 5 files changed, 148 insertions(+), 73 deletions(-) diff --git a/crates/blockifier/feature_contracts/cairo0/account_with_long_validate.cairo b/crates/blockifier/feature_contracts/cairo0/account_with_long_validate.cairo index 7605443b673..1576cfb2704 100644 --- a/crates/blockifier/feature_contracts/cairo0/account_with_long_validate.cairo +++ b/crates/blockifier/feature_contracts/cairo0/account_with_long_validate.cairo @@ -49,7 +49,7 @@ func __validate_deploy__( @external func __validate__(contract_address, selector: felt, calldata_len: felt, calldata: felt*) { - grind(); + grind_recurse(calldata[0]); return (); } diff --git a/crates/blockifier/feature_contracts/cairo0/compiled/account_with_long_validate_compiled.json b/crates/blockifier/feature_contracts/cairo0/compiled/account_with_long_validate_compiled.json index fe5611c9b28..1d4924c5a03 100644 --- a/crates/blockifier/feature_contracts/cairo0/compiled/account_with_long_validate_compiled.json +++ b/crates/blockifier/feature_contracts/cairo0/compiled/account_with_long_validate_compiled.json @@ -114,11 +114,11 @@ ], "EXTERNAL": [ { - "offset": 161, + "offset": 162, "selector": "0x15d40a3d6ca2ac30f4031e42be28da9b056fef9bb7357ac5e85627ee876e5ad" }, { - "offset": 122, + "offset": 123, "selector": "0x162da33a4585851fe8d3af3c2a9c60b557814e221e0d4f30ff0b2189d9c7775" }, { @@ -259,8 +259,9 @@ "0x0", "0x48127ffb7fff8000", "0x208b7fff7fff7ffe", + "0x480280007ffd8000", "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc9", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffcd", "0x208b7fff7fff7ffe", "0x480280027ffb8000", "0x480280027ffd8000", @@ -276,7 +277,7 @@ "0x482680017ffd8000", "0x3", "0x1104800180018000", - "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff1", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff0", "0x40780017fff7fff", "0x1", "0x480280027ffb8000", @@ -294,7 +295,7 @@ "0x480a7ffc7fff8000", "0x480a7ffd7fff8000", "0x1104800180018000", - "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff68", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff67", "0x48127ffd7fff8000", "0x480a7ff87fff8000", "0x480a7ff97fff8000", @@ -415,7 +416,7 @@ } } ], - "137": [ + "138": [ { "accessible_scopes": [ "__main__", @@ -448,7 +449,7 @@ "external", "raw_output" ], - "pc": 148, + "pc": 149, "type": "function" }, "__main__.__execute__.Args": { @@ -854,7 +855,7 @@ "external", "raw_output" ], - "pc": 161, + "pc": 162, "type": "function" }, "__wrappers__.__execute__.Args": { @@ -889,7 +890,7 @@ "decorators": [ "external" ], - "pc": 122, + "pc": 123, "type": "function" }, "__wrappers__.__validate__.Args": { diff --git a/crates/blockifier/feature_contracts/cairo1/account_with_long_validate.cairo b/crates/blockifier/feature_contracts/cairo1/account_with_long_validate.cairo index 1b4e267ec2a..f9f3dcdb852 100644 --- a/crates/blockifier/feature_contracts/cairo1/account_with_long_validate.cairo +++ b/crates/blockifier/feature_contracts/cairo1/account_with_long_validate.cairo @@ -54,7 +54,7 @@ mod Account { selector: felt252, calldata: Array ) -> felt252 { - grind(); + grind_recurse(*calldata[0]); starknet::VALIDATED } diff --git a/crates/blockifier/feature_contracts/cairo1/compiled/account_with_long_validate.casm.json b/crates/blockifier/feature_contracts/cairo1/compiled/account_with_long_validate.casm.json index 27ba33d097b..fd4952cfe0a 100644 --- a/crates/blockifier/feature_contracts/cairo1/compiled/account_with_long_validate.casm.json +++ b/crates/blockifier/feature_contracts/cairo1/compiled/account_with_long_validate.casm.json @@ -118,9 +118,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x4cc", + "0x4ea", "0x482480017fff8000", - "0x4cb", + "0x4e9", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -147,7 +147,7 @@ "0x480680017fff8000", "0x989680", "0x1104800180018000", - "0x427", + "0x445", "0x20680017fff7ffd", "0x12", "0x48127ffb7fff8000", @@ -313,9 +313,9 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x409", + "0x427", "0x482480017fff8000", - "0x408", + "0x426", "0x480080007fff8000", "0xa0680017fff8000", "0x9", @@ -335,7 +335,7 @@ "0x480680017fff8000", "0x989680", "0x1104800180018000", - "0x36b", + "0x389", "0x20680017fff7ffd", "0x10", "0x40780017fff7fff", @@ -410,7 +410,7 @@ "0x100000000000000000000000000000000", "0x400280007ff97fff", "0x10780017fff7fff", - "0x10b", + "0x129", "0x4825800180007ffa", "0x0", "0x400280007ff97fff", @@ -436,7 +436,7 @@ "0x480680017fff8000", "0x0", "0x20680017fff7ffe", - "0xe0", + "0xfe", "0xa0680017fff8004", "0xe", "0x4824800180047ffe", @@ -450,7 +450,7 @@ "0xffffffffffffffeeffffffffffffffff", "0x400080027ff47ffd", "0x10780017fff7fff", - "0xce", + "0xec", "0x484480017fff8001", "0x8000000000000000000000000000000", "0x48307fff80007ffd", @@ -481,7 +481,7 @@ "0x480680017fff8000", "0x0", "0x20680017fff7ffe", - "0xa1", + "0xbf", "0x48307ffc80007ffd", "0x20680017fff7fff", "0x4", @@ -513,7 +513,7 @@ "0x48127ffa7fff8000", "0x480080007ff88000", "0x1104800180018000", - "0x2e5", + "0x303", "0x20680017fff7ffa", "0xb", "0x48127ff87fff8000", @@ -544,7 +544,7 @@ "0x480680017fff8000", "0x0", "0x20680017fff7ffd", - "0x54", + "0x72", "0x48307ffb80007ffc", "0x20680017fff7fff", "0x4", @@ -565,29 +565,42 @@ "0x1", "0x208b7fff7fff7ffe", "0x1104800180018000", - "0x30d", + "0x32b", "0x482480017fff8000", - "0x30c", + "0x32a", "0x480080007fff8000", "0xa0680017fff8000", "0x9", "0x4824800180007ff4", - "0x50a", + "0x8d4", "0x482480017fff8000", "0x100000000000000000000000000000000", "0x400080007ff17fff", "0x10780017fff7fff", - "0x24", + "0x42", "0x4824800180007ff4", - "0x50a", + "0x8d4", "0x400080007ff27fff", - "0x482480017ff28000", - "0x1", - "0x48127ffe7fff8000", "0x480680017fff8000", - "0x989680", + "0x0", + "0x48307ff680007ff7", + "0xa0680017fff8000", + "0x6", + "0x48307ffe80007ffd", + "0x400080017fee7fff", + "0x10780017fff7fff", + "0x23", + "0x482480017ffd8000", + "0x1", + "0x48307fff80007ffd", + "0x400080017fed7fff", + "0x48307ffb7ff28000", + "0x482480017fec8000", + "0x2", + "0x48127ff87fff8000", + "0x480080007ffd8000", "0x1104800180018000", - "0x26f", + "0x280", "0x20680017fff7ffd", "0x10", "0x40780017fff7fff", @@ -606,6 +619,23 @@ "0x208b7fff7fff7ffe", "0x48127ffb7fff8000", "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x10780017fff7fff", + "0xd", + "0x40780017fff7fff", + "0x1", + "0x480680017fff8000", + "0x496e646578206f7574206f6620626f756e6473", + "0x400080007ffe7fff", + "0x482480017fec8000", + "0x2", + "0x48127ff87fff8000", + "0x48127ffc7fff8000", + "0x482480017ffb8000", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", "0x480a7ffb7fff8000", "0x480680017fff8000", "0x1", @@ -1349,7 +1379,7 @@ "bytecode_segment_lengths": [ 258, 144, - 287, + 317, 334, 184, 44, @@ -1747,7 +1777,7 @@ { "TestLessThanOrEqual": { "lhs": { - "Immediate": "0x50a" + "Immediate": "0x8d4" }, "rhs": { "Deref": { @@ -1764,7 +1794,45 @@ ] ], [ - 588, + 582, + [ + { + "TestLessThan": { + "lhs": { + "Deref": { + "register": "AP", + "offset": -2 + } + }, + "rhs": { + "Deref": { + "register": "AP", + "offset": -1 + } + }, + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 601, + [ + { + "AllocSegment": { + "dst": { + "register": "AP", + "offset": 0 + } + } + } + ] + ], + [ + 621, [ { "AllocSegment": { @@ -1777,7 +1845,7 @@ ] ], [ - 610, + 640, [ { "AllocSegment": { @@ -1790,7 +1858,7 @@ ] ], [ - 625, + 655, [ { "AllocSegment": { @@ -1803,7 +1871,7 @@ ] ], [ - 639, + 669, [ { "AllocSegment": { @@ -1816,7 +1884,7 @@ ] ], [ - 660, + 690, [ { "AllocSegment": { @@ -1829,7 +1897,7 @@ ] ], [ - 674, + 704, [ { "AllocSegment": { @@ -1842,7 +1910,7 @@ ] ], [ - 691, + 721, [ { "TestLessThanOrEqual": { @@ -1864,7 +1932,7 @@ ] ], [ - 725, + 755, [ { "TestLessThan": { @@ -1886,7 +1954,7 @@ ] ], [ - 729, + 759, [ { "LinearSplit": { @@ -1915,7 +1983,7 @@ ] ], [ - 739, + 769, [ { "LinearSplit": { @@ -1944,7 +2012,7 @@ ] ], [ - 792, + 822, [ { "AllocSegment": { @@ -1957,7 +2025,7 @@ ] ], [ - 839, + 869, [ { "AllocSegment": { @@ -1970,7 +2038,7 @@ ] ], [ - 858, + 888, [ { "TestLessThanOrEqual": { @@ -1992,7 +2060,7 @@ ] ], [ - 876, + 906, [ { "SystemCall": { @@ -2007,7 +2075,7 @@ ] ], [ - 894, + 924, [ { "SystemCall": { @@ -2022,7 +2090,7 @@ ] ], [ - 906, + 936, [ { "AllocSegment": { @@ -2035,7 +2103,7 @@ ] ], [ - 921, + 951, [ { "AllocSegment": { @@ -2048,7 +2116,7 @@ ] ], [ - 944, + 974, [ { "AllocSegment": { @@ -2061,7 +2129,7 @@ ] ], [ - 959, + 989, [ { "AllocSegment": { @@ -2074,7 +2142,7 @@ ] ], [ - 973, + 1003, [ { "AllocSegment": { @@ -2087,7 +2155,7 @@ ] ], [ - 994, + 1024, [ { "AllocSegment": { @@ -2100,7 +2168,7 @@ ] ], [ - 1008, + 1038, [ { "AllocSegment": { @@ -2113,7 +2181,7 @@ ] ], [ - 1023, + 1053, [ { "TestLessThanOrEqual": { @@ -2135,7 +2203,7 @@ ] ], [ - 1082, + 1112, [ { "AllocSegment": { @@ -2148,7 +2216,7 @@ ] ], [ - 1101, + 1131, [ { "TestLessThanOrEqual": { @@ -2170,7 +2238,7 @@ ] ], [ - 1126, + 1156, [ { "SystemCall": { @@ -2185,7 +2253,7 @@ ] ], [ - 1129, + 1159, [ { "AllocSegment": { @@ -2198,7 +2266,7 @@ ] ], [ - 1149, + 1179, [ { "AllocSegment": { @@ -2211,7 +2279,7 @@ ] ], [ - 1164, + 1194, [ { "AllocSegment": { @@ -2224,7 +2292,7 @@ ] ], [ - 1178, + 1208, [ { "AllocSegment": { @@ -2237,7 +2305,7 @@ ] ], [ - 1192, + 1222, [ { "AllocSegment": { @@ -2250,7 +2318,7 @@ ] ], [ - 1207, + 1237, [ { "TestLessThanOrEqual": { @@ -2272,7 +2340,7 @@ ] ], [ - 1237, + 1267, [ { "AllocSegment": { @@ -2285,7 +2353,7 @@ ] ], [ - 1251, + 1281, [ { "TestLessThanOrEqual": { @@ -2307,7 +2375,7 @@ ] ], [ - 1323, + 1353, [ { "AllocSegment": { @@ -2324,7 +2392,7 @@ "EXTERNAL": [ { "selector": "0x15d40a3d6ca2ac30f4031e42be28da9b056fef9bb7357ac5e85627ee876e5ad", - "offset": 689, + "offset": 719, "builtins": [ "range_check" ] @@ -2355,7 +2423,7 @@ "CONSTRUCTOR": [ { "selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194", - "offset": 1023, + "offset": 1053, "builtins": [ "range_check" ] diff --git a/crates/blockifier/src/transaction/account_transactions_test.rs b/crates/blockifier/src/transaction/account_transactions_test.rs index 62e48972c68..8c6fe6db2a7 100644 --- a/crates/blockifier/src/transaction/account_transactions_test.rs +++ b/crates/blockifier/src/transaction/account_transactions_test.rs @@ -466,11 +466,13 @@ fn test_max_fee_limit_validate( // Invoke a function that grinds validate (any function will do); set bounds low enough to fail // on this grind. + // Only grind a small number of iterations (in the calldata) to ensure we are limited by the + // transaction bounds, and not the global block bounds. // To ensure bounds are low enough, estimate minimal resources consumption, and set bounds // slightly above them. let tx_args = invoke_tx_args! { sender_address: grindy_account_address, - calldata: create_trivial_calldata(contract_address), + calldata: create_calldata(contract_address, "return_result", &[1000_u32.into()]), version, nonce: nonce_manager.next(grindy_account_address) }; @@ -486,6 +488,9 @@ fn test_max_fee_limit_validate( let estimated_min_fee = get_fee_by_gas_vector(block_info, estimated_min_gas_usage_vector, &account_tx.fee_type()); + // Make sure the resource bounds are the limiting factor by blowing up the block bounds. + let old_validate_max_n_steps = block_context.versioned_constants.validate_max_n_steps; + block_context.versioned_constants.validate_max_n_steps = u32::MAX; let error_trace = run_invoke_tx( &mut state, &block_context, @@ -523,6 +528,7 @@ fn test_max_fee_limit_validate( ) .unwrap_err() .to_string(); + block_context.versioned_constants.validate_max_n_steps = old_validate_max_n_steps; assert!(error_trace.contains("no remaining steps")); } From 8fa8073e1ceab0a72a78e6cdc2bd13065ec19494 Mon Sep 17 00:00:00 2001 From: Ayelet Zilber <138376632+ayeletstarkware@users.noreply.github.com> Date: Thu, 10 Oct 2024 11:04:14 +0300 Subject: [PATCH 46/57] refactor(blockifier): replace BouncerConfig default by create_for_testing (#1283) --- .../blockifier/transaction_executor_test.rs | 4 ++-- crates/blockifier/src/bouncer.rs | 4 ---- .../blockifier/src/test_utils/struct_impls.rs | 21 ++++++++++++++++++- 3 files changed, 22 insertions(+), 7 deletions(-) diff --git a/crates/blockifier/src/blockifier/transaction_executor_test.rs b/crates/blockifier/src/blockifier/transaction_executor_test.rs index b6987122e3d..0087cec7259 100644 --- a/crates/blockifier/src/blockifier/transaction_executor_test.rs +++ b/crates/blockifier/src/blockifier/transaction_executor_test.rs @@ -239,7 +239,7 @@ fn test_l1_handler(block_context: BlockContext) { } #[rstest] -#[case::happy_flow(BouncerWeights::default(), 10)] +#[case::happy_flow(BouncerWeights::empty(), 10)] #[should_panic(expected = "BlockFull: Transaction cannot be added to the current block, block \ capacity reached.")] #[case::block_full( @@ -250,7 +250,7 @@ fn test_l1_handler(block_context: BlockContext) { 7 )] #[should_panic(expected = "Transaction size exceeds the maximum block capacity.")] -#[case::transaction_too_large(BouncerWeights::default(), 11)] +#[case::transaction_too_large(BouncerWeights::empty(), 11)] fn test_bouncing(#[case] initial_bouncer_weights: BouncerWeights, #[case] n_events: usize) { let max_n_events_in_block = 10; diff --git a/crates/blockifier/src/bouncer.rs b/crates/blockifier/src/bouncer.rs index 1508eeea315..462ac20c657 100644 --- a/crates/blockifier/src/bouncer.rs +++ b/crates/blockifier/src/bouncer.rs @@ -48,10 +48,6 @@ impl BouncerConfig { Self { block_max_capacity: BouncerWeights::max() } } - pub fn empty() -> Self { - Self::default() - } - pub fn has_room(&self, weights: BouncerWeights) -> bool { self.block_max_capacity.has_room(weights) } diff --git a/crates/blockifier/src/test_utils/struct_impls.rs b/crates/blockifier/src/test_utils/struct_impls.rs index 3e3808e9d50..f3061a06994 100644 --- a/crates/blockifier/src/test_utils/struct_impls.rs +++ b/crates/blockifier/src/test_utils/struct_impls.rs @@ -19,7 +19,7 @@ use super::update_json_value; use crate::abi::abi_utils::selector_from_name; use crate::abi::constants; use crate::blockifier::block::{BlockInfo, BlockNumberHashPair, GasPrices}; -use crate::bouncer::{BouncerConfig, BouncerWeights}; +use crate::bouncer::{BouncerConfig, BouncerWeights, BuiltinCount}; use crate::context::{BlockContext, ChainInfo, FeeTokenAddresses, TransactionContext}; use crate::execution::call_info::{CallExecution, CallInfo, Retdata}; use crate::execution::contract_class::{ContractClassV0, ContractClassV1}; @@ -278,3 +278,22 @@ impl L1HandlerTransaction { Self { tx, tx_hash, paid_fee_on_l1: l1_fee } } } + +impl BouncerConfig { + pub fn empty() -> Self { + Self { block_max_capacity: BouncerWeights::empty() } + } +} + +impl BouncerWeights { + pub fn empty() -> Self { + Self { + n_events: 0, + builtin_count: BuiltinCount::default(), + gas: 0, + message_segment_length: 0, + n_steps: 0, + state_diff_size: 0, + } + } +} From 28385eb2fa928c0bf99f7ac3c95ebf5a37593008 Mon Sep 17 00:00:00 2001 From: aner-starkware <147302140+aner-starkware@users.noreply.github.com> Date: Thu, 10 Oct 2024 11:55:51 +0300 Subject: [PATCH 47/57] refactor(starknet_api): compiler refactor recommendation (#1288) --- crates/starknet_api/src/transaction.rs | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/crates/starknet_api/src/transaction.rs b/crates/starknet_api/src/transaction.rs index edb343cd582..a3d3e28e0bc 100644 --- a/crates/starknet_api/src/transaction.rs +++ b/crates/starknet_api/src/transaction.rs @@ -751,14 +751,9 @@ impl Fee { } pub fn checked_div_ceil(self, rhs: NonzeroGasPrice) -> Option { - match self.checked_div(rhs) { - Some(value) => Some(if value.nonzero_saturating_mul(rhs) < self { - (value.0 + 1).into() - } else { - value - }), - None => None, - } + self.checked_div(rhs).map(|value| { + if value.nonzero_saturating_mul(rhs) < self { (value.0 + 1).into() } else { value } + }) } pub fn checked_div(self, rhs: NonzeroGasPrice) -> Option { From 778ab3a833ab998c0fe83c30d56f0e83c3a0c64b Mon Sep 17 00:00:00 2001 From: Itay Tsabary Date: Wed, 9 Oct 2024 22:17:12 +0300 Subject: [PATCH 48/57] fix(mempool_node): fix gateway config to point to chain_id commit-id:24ddd75d --- config/mempool/default_config.json | 6 +++--- crates/mempool_node/src/config/mod.rs | 31 +++++++++++++++++++++++---- 2 files changed, 30 insertions(+), 7 deletions(-) diff --git a/config/mempool/default_config.json b/config/mempool/default_config.json index b2065437427..a9912f3c419 100644 --- a/config/mempool/default_config.json +++ b/config/mempool/default_config.json @@ -122,7 +122,7 @@ "components.consensus_manager.execute": { "description": "The component execution flag.", "privacy": "Public", - "value": true + "value": false }, "components.consensus_manager.execution_mode": { "description": "The component execution mode.", @@ -306,8 +306,8 @@ }, "gateway_config.chain_info.chain_id": { "description": "The chain ID of the StarkNet chain.", - "privacy": "Public", - "value": "0x0" + "pointer_target": "chain_id", + "privacy": "Public" }, "gateway_config.chain_info.fee_token_addresses.eth_fee_token_address": { "description": "Address of the ETH fee token.", diff --git a/crates/mempool_node/src/config/mod.rs b/crates/mempool_node/src/config/mod.rs index 55f86800a0b..e3012015390 100644 --- a/crates/mempool_node/src/config/mod.rs +++ b/crates/mempool_node/src/config/mod.rs @@ -15,6 +15,7 @@ use papyrus_config::dumping::{ SerializeConfig, }; use papyrus_config::loading::load_and_process_config; +use papyrus_config::validators::validate_ascii; use papyrus_config::{ConfigError, ParamPath, ParamPrivacyInput, SerializedParam}; use serde::{Deserialize, Serialize}; use starknet_api::core::ChainId; @@ -36,10 +37,14 @@ pub const DEFAULT_CONFIG_PATH: &str = "config/mempool/default_config.json"; // Configuration parameters that share the same value across multiple components. type ConfigPointers = Vec<((ParamPath, SerializedParam), Vec)>; +pub const DEFAULT_CHAIN_ID: ChainId = ChainId::Mainnet; pub static CONFIG_POINTERS: LazyLock = LazyLock::new(|| { vec![( - ser_pointer_target_param("chain_id", &ChainId::Mainnet, "The chain to follow."), - vec!["batcher_config.storage.db_config.chain_id".to_owned()], + ser_pointer_target_param("chain_id", &DEFAULT_CHAIN_ID, "The chain to follow."), + vec![ + "batcher_config.storage.db_config.chain_id".to_owned(), + "gateway_config.chain_info.chain_id".to_owned(), + ], )] }); @@ -144,7 +149,7 @@ impl ComponentExecutionConfig { pub fn consensus_manager_default_config() -> Self { Self { - execute: true, + execute: false, execution_mode: ComponentExecutionMode::Local, local_config: Some(LocalComponentCommunicationConfig::default()), remote_config: None, @@ -237,8 +242,11 @@ pub fn validate_components_config(components: &ComponentConfig) -> Result<(), Va } /// The configurations of the various components of the node. -#[derive(Debug, Deserialize, Default, Serialize, Clone, PartialEq, Validate)] +#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Validate)] pub struct SequencerNodeConfig { + /// The [chain id](https://docs.rs/starknet_api/latest/starknet_api/core/struct.ChainId.html) of the Starknet network. + #[validate(custom = "validate_ascii")] + pub chain_id: ChainId, #[validate] pub components: ComponentConfig, #[validate] @@ -275,6 +283,21 @@ impl SerializeConfig for SequencerNodeConfig { } } +impl Default for SequencerNodeConfig { + fn default() -> Self { + Self { + chain_id: DEFAULT_CHAIN_ID, + components: Default::default(), + batcher_config: Default::default(), + consensus_manager_config: Default::default(), + gateway_config: Default::default(), + http_server_config: Default::default(), + rpc_state_reader_config: Default::default(), + compiler_config: Default::default(), + } + } +} + impl SequencerNodeConfig { /// Creates a config object. Selects the values from the default file and from resources with /// higher priority. From 0df480a26af0bc8ea53709af9f13d6acc02d1e39 Mon Sep 17 00:00:00 2001 From: Nadin Jbara <93648739+nadin-Starkware@users.noreply.github.com> Date: Thu, 10 Oct 2024 13:14:56 +0300 Subject: [PATCH 49/57] chore: extend remote communication config (#1207) --- config/mempool/default_config.json | 110 +++++++++++++----- .../remote_component_client.rs | 10 +- .../src/component_definitions.rs | 65 +++++++++-- .../remote_component_server.rs | 14 +-- .../remote_component_client_server_test.rs | 29 ++--- crates/mempool_node/src/config/config_test.rs | 92 +++++++++++---- crates/mempool_node/src/config/mod.rs | 66 +++++++---- 7 files changed, 274 insertions(+), 112 deletions(-) diff --git a/config/mempool/default_config.json b/config/mempool/default_config.json index a9912f3c419..2ae0825ee40 100644 --- a/config/mempool/default_config.json +++ b/config/mempool/default_config.json @@ -94,28 +94,38 @@ "privacy": "Public", "value": 32 }, - "components.batcher.remote_config.#is_none": { + "components.batcher.remote_client_config.#is_none": { "description": "Flag for an optional field.", "privacy": "TemporaryValue", "value": true }, - "components.batcher.remote_config.idle_connections": { + "components.batcher.remote_client_config.idle_connections": { "description": "The maximum number of idle connections to keep alive.", "privacy": "Public", "value": 18446744073709551615 }, - "components.batcher.remote_config.idle_timeout": { + "components.batcher.remote_client_config.idle_timeout": { "description": "The duration in seconds to keep an idle connection open before closing.", "privacy": "Public", "value": 90 }, - "components.batcher.remote_config.retries": { + "components.batcher.remote_client_config.retries": { "description": "The max number of retries for sending a message.", "privacy": "Public", "value": 3 }, - "components.batcher.remote_config.socket": { - "description": "The remote component server socket.", + "components.batcher.remote_client_config.socket": { + "description": "The remote component socket.", + "privacy": "Public", + "value": "0.0.0.0:8080" + }, + "components.batcher.remote_server_config.#is_none": { + "description": "Flag for an optional field.", + "privacy": "TemporaryValue", + "value": true + }, + "components.batcher.remote_server_config.socket": { + "description": "The remote component socket.", "privacy": "Public", "value": "0.0.0.0:8080" }, @@ -139,28 +149,38 @@ "privacy": "Public", "value": 32 }, - "components.consensus_manager.remote_config.#is_none": { + "components.consensus_manager.remote_client_config.#is_none": { "description": "Flag for an optional field.", "privacy": "TemporaryValue", "value": true }, - "components.consensus_manager.remote_config.idle_connections": { + "components.consensus_manager.remote_client_config.idle_connections": { "description": "The maximum number of idle connections to keep alive.", "privacy": "Public", "value": 18446744073709551615 }, - "components.consensus_manager.remote_config.idle_timeout": { + "components.consensus_manager.remote_client_config.idle_timeout": { "description": "The duration in seconds to keep an idle connection open before closing.", "privacy": "Public", "value": 90 }, - "components.consensus_manager.remote_config.retries": { + "components.consensus_manager.remote_client_config.retries": { "description": "The max number of retries for sending a message.", "privacy": "Public", "value": 3 }, - "components.consensus_manager.remote_config.socket": { - "description": "The remote component server socket.", + "components.consensus_manager.remote_client_config.socket": { + "description": "The remote component socket.", + "privacy": "Public", + "value": "0.0.0.0:8080" + }, + "components.consensus_manager.remote_server_config.#is_none": { + "description": "Flag for an optional field.", + "privacy": "TemporaryValue", + "value": true + }, + "components.consensus_manager.remote_server_config.socket": { + "description": "The remote component socket.", "privacy": "Public", "value": "0.0.0.0:8080" }, @@ -184,28 +204,38 @@ "privacy": "Public", "value": 32 }, - "components.gateway.remote_config.#is_none": { + "components.gateway.remote_client_config.#is_none": { "description": "Flag for an optional field.", "privacy": "TemporaryValue", "value": true }, - "components.gateway.remote_config.idle_connections": { + "components.gateway.remote_client_config.idle_connections": { "description": "The maximum number of idle connections to keep alive.", "privacy": "Public", "value": 18446744073709551615 }, - "components.gateway.remote_config.idle_timeout": { + "components.gateway.remote_client_config.idle_timeout": { "description": "The duration in seconds to keep an idle connection open before closing.", "privacy": "Public", "value": 90 }, - "components.gateway.remote_config.retries": { + "components.gateway.remote_client_config.retries": { "description": "The max number of retries for sending a message.", "privacy": "Public", "value": 3 }, - "components.gateway.remote_config.socket": { - "description": "The remote component server socket.", + "components.gateway.remote_client_config.socket": { + "description": "The remote component socket.", + "privacy": "Public", + "value": "0.0.0.0:8080" + }, + "components.gateway.remote_server_config.#is_none": { + "description": "Flag for an optional field.", + "privacy": "TemporaryValue", + "value": true + }, + "components.gateway.remote_server_config.socket": { + "description": "The remote component socket.", "privacy": "Public", "value": "0.0.0.0:8080" }, @@ -229,28 +259,38 @@ "privacy": "Public", "value": 32 }, - "components.http_server.remote_config.#is_none": { + "components.http_server.remote_client_config.#is_none": { "description": "Flag for an optional field.", "privacy": "TemporaryValue", "value": false }, - "components.http_server.remote_config.idle_connections": { + "components.http_server.remote_client_config.idle_connections": { "description": "The maximum number of idle connections to keep alive.", "privacy": "Public", "value": 18446744073709551615 }, - "components.http_server.remote_config.idle_timeout": { + "components.http_server.remote_client_config.idle_timeout": { "description": "The duration in seconds to keep an idle connection open before closing.", "privacy": "Public", "value": 90 }, - "components.http_server.remote_config.retries": { + "components.http_server.remote_client_config.retries": { "description": "The max number of retries for sending a message.", "privacy": "Public", "value": 3 }, - "components.http_server.remote_config.socket": { - "description": "The remote component server socket.", + "components.http_server.remote_client_config.socket": { + "description": "The remote component socket.", + "privacy": "Public", + "value": "0.0.0.0:8080" + }, + "components.http_server.remote_server_config.#is_none": { + "description": "Flag for an optional field.", + "privacy": "TemporaryValue", + "value": true + }, + "components.http_server.remote_server_config.socket": { + "description": "The remote component socket.", "privacy": "Public", "value": "0.0.0.0:8080" }, @@ -274,28 +314,38 @@ "privacy": "Public", "value": 32 }, - "components.mempool.remote_config.#is_none": { + "components.mempool.remote_client_config.#is_none": { "description": "Flag for an optional field.", "privacy": "TemporaryValue", "value": true }, - "components.mempool.remote_config.idle_connections": { + "components.mempool.remote_client_config.idle_connections": { "description": "The maximum number of idle connections to keep alive.", "privacy": "Public", "value": 18446744073709551615 }, - "components.mempool.remote_config.idle_timeout": { + "components.mempool.remote_client_config.idle_timeout": { "description": "The duration in seconds to keep an idle connection open before closing.", "privacy": "Public", "value": 90 }, - "components.mempool.remote_config.retries": { + "components.mempool.remote_client_config.retries": { "description": "The max number of retries for sending a message.", "privacy": "Public", "value": 3 }, - "components.mempool.remote_config.socket": { - "description": "The remote component server socket.", + "components.mempool.remote_client_config.socket": { + "description": "The remote component socket.", + "privacy": "Public", + "value": "0.0.0.0:8080" + }, + "components.mempool.remote_server_config.#is_none": { + "description": "Flag for an optional field.", + "privacy": "TemporaryValue", + "value": true + }, + "components.mempool.remote_server_config.socket": { + "description": "The remote component socket.", "privacy": "Public", "value": "0.0.0.0:8080" }, diff --git a/crates/mempool_infra/src/component_client/remote_component_client.rs b/crates/mempool_infra/src/component_client/remote_component_client.rs index 2537170871c..cf1b04f8a03 100644 --- a/crates/mempool_infra/src/component_client/remote_component_client.rs +++ b/crates/mempool_infra/src/component_client/remote_component_client.rs @@ -11,7 +11,7 @@ use serde::de::DeserializeOwned; use serde::Serialize; use super::definitions::{ClientError, ClientResult}; -use crate::component_definitions::{RemoteComponentCommunicationConfig, APPLICATION_OCTET_STREAM}; +use crate::component_definitions::{RemoteClientConfig, APPLICATION_OCTET_STREAM}; use crate::serde_utils::BincodeSerdeWrapper; /// The `RemoteComponentClient` struct is a generic client for sending component requests and @@ -34,7 +34,7 @@ use crate::serde_utils::BincodeSerdeWrapper; /// use serde::{Deserialize, Serialize}; /// /// use crate::starknet_mempool_infra::component_client::RemoteComponentClient; -/// use crate::starknet_mempool_infra::component_definitions::RemoteComponentCommunicationConfig; +/// use crate::starknet_mempool_infra::component_definitions::RemoteClientConfig; /// /// // Define your request and response types /// #[derive(Serialize, Deserialize, Debug, Clone)] @@ -54,7 +54,7 @@ use crate::serde_utils::BincodeSerdeWrapper; /// let ip_address = std::net::IpAddr::V6(std::net::Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)); /// let port: u16 = 8080; /// let socket = std::net::SocketAddr::new(ip_address, port); -/// let config = RemoteComponentCommunicationConfig { +/// let config = RemoteClientConfig { /// socket, /// retries: 3, /// idle_connections: usize::MAX, @@ -81,7 +81,7 @@ where { uri: Uri, client: Client, - config: RemoteComponentCommunicationConfig, + config: RemoteClientConfig, _req: PhantomData, _res: PhantomData, } @@ -91,7 +91,7 @@ where Request: Serialize + DeserializeOwned + Debug + Clone, Response: Serialize + DeserializeOwned + Debug, { - pub fn new(config: RemoteComponentCommunicationConfig) -> Self { + pub fn new(config: RemoteClientConfig) -> Self { let ip_address = config.socket.ip(); let port = config.socket.port(); let uri = match ip_address { diff --git a/crates/mempool_infra/src/component_definitions.rs b/crates/mempool_infra/src/component_definitions.rs index c4b63598659..73f03b0dfa1 100644 --- a/crates/mempool_infra/src/component_definitions.rs +++ b/crates/mempool_infra/src/component_definitions.rs @@ -4,7 +4,7 @@ use std::fmt::Debug; use std::net::{IpAddr, Ipv4Addr, SocketAddr}; use async_trait::async_trait; -use papyrus_config::dumping::{ser_param, SerializeConfig}; +use papyrus_config::dumping::{append_sub_config_name, ser_param, SerializeConfig}; use papyrus_config::{ParamPath, ParamPrivacyInput, SerializedParam}; use serde::{Deserialize, Serialize}; use thiserror::Error; @@ -67,6 +67,9 @@ pub enum ServerError { RequestDeserializationFailure(String), } +// TODO(Nadin): Refactor this into two separate structs: LocalClientConfig (empty struct for the +// client) and LocalServerConfig (which holds the current channel_buffer_size field). + // The communication configuration of the local component. #[derive(Clone, Debug, Serialize, Deserialize, Validate, PartialEq)] pub struct LocalComponentCommunicationConfig { @@ -90,22 +93,33 @@ impl Default for LocalComponentCommunicationConfig { } } -// The communication configuration of the remote component. #[derive(Clone, Debug, Serialize, Deserialize, Validate, PartialEq)] -pub struct RemoteComponentCommunicationConfig { +pub struct RemoteClientConfig { pub socket: SocketAddr, pub retries: usize, pub idle_connections: usize, pub idle_timeout: u64, } -impl SerializeConfig for RemoteComponentCommunicationConfig { +impl Default for RemoteClientConfig { + fn default() -> Self { + let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 8080); + Self { + socket, + retries: DEFAULT_RETRIES, + idle_connections: DEFAULT_IDLE_CONNECTIONS, + idle_timeout: DEFAULT_IDLE_TIMEOUT, + } + } +} + +impl SerializeConfig for RemoteClientConfig { fn dump(&self) -> BTreeMap { BTreeMap::from_iter([ ser_param( "socket", &self.socket.to_string(), - "The remote component server socket.", + "The remote component socket.", ParamPrivacyInput::Public, ), ser_param( @@ -130,14 +144,41 @@ impl SerializeConfig for RemoteComponentCommunicationConfig { } } -impl Default for RemoteComponentCommunicationConfig { +#[derive(Clone, Debug, Serialize, Deserialize, Validate, PartialEq)] +pub struct RemoteServerConfig { + pub socket: SocketAddr, +} + +impl Default for RemoteServerConfig { fn default() -> Self { let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 8080); - Self { - socket, - retries: DEFAULT_RETRIES, - idle_connections: DEFAULT_IDLE_CONNECTIONS, - idle_timeout: DEFAULT_IDLE_TIMEOUT, - } + Self { socket } + } +} + +impl SerializeConfig for RemoteServerConfig { + fn dump(&self) -> BTreeMap { + BTreeMap::from_iter([ser_param( + "socket", + &self.socket.to_string(), + "The remote component socket.", + ParamPrivacyInput::Public, + )]) + } +} + +// The communication configuration of the remote component. +#[derive(Clone, Default, Debug, Serialize, Deserialize, Validate, PartialEq)] +pub struct RemoteComponentCommunicationConfig { + pub client_config: RemoteClientConfig, + pub server_config: RemoteServerConfig, +} + +impl SerializeConfig for RemoteComponentCommunicationConfig { + fn dump(&self) -> BTreeMap { + let mut result = append_sub_config_name(self.client_config.dump(), "client_config"); + let server_config_dump = append_sub_config_name(self.server_config.dump(), "server_config"); + result.extend(server_config_dump); + result } } diff --git a/crates/mempool_infra/src/component_server/remote_component_server.rs b/crates/mempool_infra/src/component_server/remote_component_server.rs index cee15022c8e..fd089d9b6ac 100644 --- a/crates/mempool_infra/src/component_server/remote_component_server.rs +++ b/crates/mempool_infra/src/component_server/remote_component_server.rs @@ -1,5 +1,5 @@ use std::fmt::Debug; -use std::net::{IpAddr, SocketAddr}; +use std::net::SocketAddr; use std::sync::Arc; use async_trait::async_trait; @@ -11,7 +11,7 @@ use serde::de::DeserializeOwned; use serde::Serialize; use crate::component_client::{ClientError, LocalComponentClient}; -use crate::component_definitions::{ServerError, APPLICATION_OCTET_STREAM}; +use crate::component_definitions::{RemoteServerConfig, ServerError, APPLICATION_OCTET_STREAM}; use crate::component_server::ComponentServerStarter; use crate::errors::ComponentServerError; use crate::serde_utils::BincodeSerdeWrapper; @@ -47,6 +47,7 @@ use crate::serde_utils::BincodeSerdeWrapper; /// use crate::starknet_mempool_infra::component_definitions::{ /// ComponentRequestHandler, /// ComponentStarter, +/// RemoteServerConfig, /// }; /// use crate::starknet_mempool_infra::component_server::{ /// ComponentServerStarter, @@ -87,10 +88,10 @@ use crate::serde_utils::BincodeSerdeWrapper; /// // Set the ip address and port of the server's socket. /// let ip_address = std::net::IpAddr::V6(std::net::Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1)); /// let port: u16 = 8080; +/// let config = RemoteServerConfig { socket: std::net::SocketAddr::new(ip_address, port) }; /// /// // Instantiate the server. -/// let mut server = -/// RemoteComponentServer::::new(local_client, ip_address, port); +/// let mut server = RemoteComponentServer::::new(local_client, config); /// /// // Start the server in a new task. /// task::spawn(async move { @@ -114,10 +115,9 @@ where { pub fn new( local_client: LocalComponentClient, - ip_address: IpAddr, - port: u16, + config: RemoteServerConfig, ) -> Self { - Self { local_client, socket: SocketAddr::new(ip_address, port) } + Self { local_client, socket: config.socket } } async fn remote_component_server_handler( diff --git a/crates/mempool_infra/src/tests/remote_component_client_server_test.rs b/crates/mempool_infra/src/tests/remote_component_client_server_test.rs index f7b58c8a5de..00b61c0c034 100644 --- a/crates/mempool_infra/src/tests/remote_component_client_server_test.rs +++ b/crates/mempool_infra/src/tests/remote_component_client_server_test.rs @@ -23,7 +23,8 @@ use crate::component_client::{ }; use crate::component_definitions::{ ComponentRequestAndResponseSender, - RemoteComponentCommunicationConfig, + RemoteClientConfig, + RemoteServerConfig, ServerError, APPLICATION_OCTET_STREAM, }; @@ -141,13 +142,13 @@ where // Ensure the server starts running. task::yield_now().await; - let config = RemoteComponentCommunicationConfig { socket, ..Default::default() }; + let config = RemoteClientConfig { socket, ..Default::default() }; ComponentAClient::new(config) } async fn setup_for_tests(setup_value: ValueB, a_socket: SocketAddr, b_socket: SocketAddr) { - let a_config = RemoteComponentCommunicationConfig { socket: a_socket, ..Default::default() }; - let b_config = RemoteComponentCommunicationConfig { socket: b_socket, ..Default::default() }; + let a_config = RemoteClientConfig { socket: a_socket, ..Default::default() }; + let b_config = RemoteClientConfig { socket: b_socket, ..Default::default() }; let a_remote_client = ComponentAClient::new(a_config); let b_remote_client = ComponentBClient::new(b_config); @@ -167,9 +168,9 @@ async fn setup_for_tests(setup_value: ValueB, a_socket: SocketAddr, b_socket: So let mut component_b_local_server = LocalComponentServer::new(component_b, rx_b); let mut component_a_remote_server = - RemoteComponentServer::new(a_local_client, a_socket.ip(), a_socket.port()); + RemoteComponentServer::new(a_local_client, RemoteServerConfig { socket: a_socket }); let mut component_b_remote_server = - RemoteComponentServer::new(b_local_client, b_socket.ip(), b_socket.port()); + RemoteComponentServer::new(b_local_client, RemoteServerConfig { socket: b_socket }); task::spawn(async move { let _ = component_a_local_server.start().await; @@ -197,11 +198,11 @@ async fn test_proper_setup() { let b_socket = get_available_socket().await; setup_for_tests(setup_value, a_socket, b_socket).await; - let a_config = RemoteComponentCommunicationConfig { socket: a_socket, ..Default::default() }; - let b_config = RemoteComponentCommunicationConfig { socket: b_socket, ..Default::default() }; + let a_client_config = RemoteClientConfig { socket: a_socket, ..Default::default() }; + let b_client_config = RemoteClientConfig { socket: b_socket, ..Default::default() }; - let a_remote_client = ComponentAClient::new(a_config); - let b_remote_client = ComponentBClient::new(b_config); + let a_remote_client = ComponentAClient::new(a_client_config); + let b_remote_client = ComponentBClient::new(b_client_config); test_a_b_functionality(a_remote_client, b_remote_client, setup_value).await; } @@ -243,8 +244,8 @@ async fn test_faulty_client_setup() { #[tokio::test] async fn test_unconnected_server() { let socket = get_available_socket().await; - let config = RemoteComponentCommunicationConfig { socket, ..Default::default() }; - let client = ComponentAClient::new(config); + let client_config = RemoteClientConfig { socket, ..Default::default() }; + let client = ComponentAClient::new(client_config); let expected_error_contained_keywords = ["Connection refused"]; verify_error(client, &expected_error_contained_keywords).await; } @@ -312,7 +313,7 @@ async fn test_retry_request() { // The initial server state is 'false', hence the first attempt returns an error and // sets the server state to 'true'. The second attempt (first retry) therefore returns a // 'success', while setting the server state to 'false' yet again. - let retry_config = RemoteComponentCommunicationConfig { + let retry_config = RemoteClientConfig { socket, retries: 1, idle_connections: MAX_IDLE_CONNECTION, @@ -322,7 +323,7 @@ async fn test_retry_request() { assert_eq!(a_client_retry.a_get_value().await.unwrap(), VALID_VALUE_A); // The current server state is 'false', hence the first and only attempt returns an error. - let no_retry_config = RemoteComponentCommunicationConfig { + let no_retry_config = RemoteClientConfig { socket, retries: 0, idle_connections: MAX_IDLE_CONNECTION, diff --git a/crates/mempool_node/src/config/config_test.rs b/crates/mempool_node/src/config/config_test.rs index a8f72484a87..a7115831193 100644 --- a/crates/mempool_node/src/config/config_test.rs +++ b/crates/mempool_node/src/config/config_test.rs @@ -10,7 +10,8 @@ use papyrus_config::validators::{ParsedValidationError, ParsedValidationErrors}; use rstest::rstest; use starknet_mempool_infra::component_definitions::{ LocalComponentCommunicationConfig, - RemoteComponentCommunicationConfig, + RemoteClientConfig, + RemoteServerConfig, }; use validator::{Validate, ValidationErrors}; @@ -51,40 +52,86 @@ fn check_validation_error( #[case( ComponentExecutionMode::Local, Some(LocalComponentCommunicationConfig::default()), - Some(RemoteComponentCommunicationConfig::default()), - "Local config and Remote config are mutually exclusive, can't be both active." + Some(RemoteClientConfig::default()), + Some(RemoteServerConfig::default()), + "Local config and Remote config are mutually exclusive in Local mode execution, can't be both \ + active." )] #[case( ComponentExecutionMode::Local, + Some(LocalComponentCommunicationConfig::default()), None, - Some(RemoteComponentCommunicationConfig::default()), - "Local communication config is missing." + Some(RemoteServerConfig::default()), + "Local config and Remote config are mutually exclusive in Local mode execution, can't be both \ + active." )] -#[case(ComponentExecutionMode::Local, None, None, "Local communication config is missing.")] #[case( - ComponentExecutionMode::Remote, + ComponentExecutionMode::Local, Some(LocalComponentCommunicationConfig::default()), - Some(RemoteComponentCommunicationConfig::default()), - "Local config and Remote config are mutually exclusive, can't be both active." + Some(RemoteClientConfig::default()), + None, + "Local config and Remote config are mutually exclusive in Local mode execution, can't be both \ + active." +)] +#[case( + ComponentExecutionMode::Local, + None, + Some(RemoteClientConfig::default()), + Some(RemoteServerConfig::default()), + "Local communication config is missing." +)] +#[case( + ComponentExecutionMode::Local, + None, + None, + Some(RemoteServerConfig::default()), + "Local communication config is missing." +)] +#[case( + ComponentExecutionMode::Local, + None, + Some(RemoteClientConfig::default()), + None, + "Local communication config is missing." )] +#[case(ComponentExecutionMode::Local, None, None, None, "Local communication config is missing.")] #[case( ComponentExecutionMode::Remote, Some(LocalComponentCommunicationConfig::default()), None, + None, "Remote communication config is missing." )] -#[case(ComponentExecutionMode::Remote, None, None, "Remote communication config is missing.")] +#[case( + ComponentExecutionMode::Remote, + None, + Some(RemoteClientConfig::default()), + Some(RemoteServerConfig::default()), + "Remote client and Remote server are mutually exclusive in Remote mode execution, can't be \ + both active." +)] +#[case( + ComponentExecutionMode::Remote, + Some(LocalComponentCommunicationConfig::default()), + Some(RemoteClientConfig::default()), + Some(RemoteServerConfig::default()), + "Remote client and Remote server are mutually exclusive in Remote mode execution, can't be \ + both active." +)] +#[case(ComponentExecutionMode::Remote, None, None, None, "Remote communication config is missing.")] fn test_invalid_component_execution_config( #[case] execution_mode: ComponentExecutionMode, #[case] local_config: Option, - #[case] remote_config: Option, + #[case] remote_client_config: Option, + #[case] remote_server_config: Option, #[case] expected_error_message: &str, ) { // Initialize an invalid config and check that the validator finds an error. let component_exe_config = ComponentExecutionConfig { execution_mode, local_config, - remote_config, + remote_client_config, + remote_server_config, ..ComponentExecutionConfig::default() }; check_validation_error( @@ -97,24 +144,27 @@ fn test_invalid_component_execution_config( /// Test the validation of the struct ComponentExecutionConfig. /// Validates that execution mode of the component and the local/remote config are at sync. #[rstest] -#[case::local(ComponentExecutionMode::Local)] -#[case::remote(ComponentExecutionMode::Remote)] -fn test_valid_component_execution_config(#[case] execution_mode: ComponentExecutionMode) { +#[case::local(ComponentExecutionMode::Local, None, None)] +#[case::remote(ComponentExecutionMode::Remote, Some(RemoteClientConfig::default()), None)] +#[case::remote(ComponentExecutionMode::Remote, None, Some(RemoteServerConfig::default()))] +fn test_valid_component_execution_config( + #[case] execution_mode: ComponentExecutionMode, + #[case] remote_client_config: Option, + #[case] remote_server_config: Option, +) { // Initialize a valid config and check that the validator returns Ok. + let local_config = if execution_mode == ComponentExecutionMode::Local { Some(LocalComponentCommunicationConfig::default()) } else { None }; - let remote_config = if execution_mode == ComponentExecutionMode::Remote { - Some(RemoteComponentCommunicationConfig::default()) - } else { - None - }; + let component_exe_config = ComponentExecutionConfig { execution_mode, local_config, - remote_config, + remote_client_config, + remote_server_config, ..ComponentExecutionConfig::default() }; assert_eq!(component_exe_config.validate(), Ok(())); diff --git a/crates/mempool_node/src/config/mod.rs b/crates/mempool_node/src/config/mod.rs index e3012015390..87921769ce3 100644 --- a/crates/mempool_node/src/config/mod.rs +++ b/crates/mempool_node/src/config/mod.rs @@ -25,7 +25,8 @@ use starknet_gateway::config::{GatewayConfig, RpcStateReaderConfig}; use starknet_http_server::config::HttpServerConfig; use starknet_mempool_infra::component_definitions::{ LocalComponentCommunicationConfig, - RemoteComponentCommunicationConfig, + RemoteClientConfig, + RemoteServerConfig, }; use starknet_sierra_compile::config::SierraToCasmCompilationConfig; use validator::{Validate, ValidationError}; @@ -65,7 +66,8 @@ pub struct ComponentExecutionConfig { pub execute: bool, pub execution_mode: ComponentExecutionMode, pub local_config: Option, - pub remote_config: Option, + pub remote_client_config: Option, + pub remote_server_config: Option, } impl SerializeConfig for ComponentExecutionConfig { @@ -87,7 +89,8 @@ impl SerializeConfig for ComponentExecutionConfig { vec![ config, ser_optional_sub_config(&self.local_config, "local_config"), - ser_optional_sub_config(&self.remote_config, "remote_config"), + ser_optional_sub_config(&self.remote_client_config, "remote_client_config"), + ser_optional_sub_config(&self.remote_server_config, "remote_server_config"), ] .into_iter() .flatten() @@ -101,7 +104,8 @@ impl Default for ComponentExecutionConfig { execute: true, execution_mode: ComponentExecutionMode::Local, local_config: Some(LocalComponentCommunicationConfig::default()), - remote_config: None, + remote_client_config: None, + remote_server_config: None, } } } @@ -113,7 +117,8 @@ impl ComponentExecutionConfig { execute: true, execution_mode: ComponentExecutionMode::Local, local_config: Some(LocalComponentCommunicationConfig::default()), - remote_config: None, + remote_client_config: None, + remote_server_config: None, } } @@ -125,7 +130,8 @@ impl ComponentExecutionConfig { execute: true, execution_mode: ComponentExecutionMode::Remote, local_config: None, - remote_config: Some(RemoteComponentCommunicationConfig::default()), + remote_client_config: Some(RemoteClientConfig::default()), + remote_server_config: None, } } @@ -134,7 +140,8 @@ impl ComponentExecutionConfig { execute: true, execution_mode: ComponentExecutionMode::Local, local_config: Some(LocalComponentCommunicationConfig::default()), - remote_config: None, + remote_client_config: None, + remote_server_config: None, } } @@ -143,7 +150,8 @@ impl ComponentExecutionConfig { execute: true, execution_mode: ComponentExecutionMode::Local, local_config: Some(LocalComponentCommunicationConfig::default()), - remote_config: None, + remote_client_config: None, + remote_server_config: None, } } @@ -152,7 +160,8 @@ impl ComponentExecutionConfig { execute: false, execution_mode: ComponentExecutionMode::Local, local_config: Some(LocalComponentCommunicationConfig::default()), - remote_config: None, + remote_client_config: None, + remote_server_config: None, } } } @@ -160,20 +169,31 @@ impl ComponentExecutionConfig { pub fn validate_single_component_config( component_config: &ComponentExecutionConfig, ) -> Result<(), ValidationError> { - let error_message = - if component_config.local_config.is_some() && component_config.remote_config.is_some() { - "Local config and Remote config are mutually exclusive, can't be both active." - } else if component_config.execution_mode == ComponentExecutionMode::Local - && component_config.local_config.is_none() - { - "Local communication config is missing." - } else if component_config.execution_mode == ComponentExecutionMode::Remote - && component_config.remote_config.is_none() - { - "Remote communication config is missing." - } else { - return Ok(()); - }; + let error_message = if component_config.execution_mode == ComponentExecutionMode::Local + && component_config.local_config.is_some() + && (component_config.remote_server_config.is_some() + || component_config.remote_client_config.is_some()) + { + "Local config and Remote config are mutually exclusive in Local mode execution, can't be \ + both active." + } else if component_config.execution_mode == ComponentExecutionMode::Local + && component_config.local_config.is_none() + { + "Local communication config is missing." + } else if component_config.execution_mode == ComponentExecutionMode::Remote + && component_config.remote_server_config.is_none() + && component_config.remote_client_config.is_none() + { + "Remote communication config is missing." + } else if component_config.execution_mode == ComponentExecutionMode::Remote + && component_config.remote_server_config.is_some() + && component_config.remote_client_config.is_some() + { + "Remote client and Remote server are mutually exclusive in Remote mode execution, can't be \ + both active." + } else { + return Ok(()); + }; let mut error = ValidationError::new("Invalid component configuration."); error.message = Some(error_message.into()); From 71afbf73e5ab5df2c153887ade491e04d6df686a Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Thu, 10 Oct 2024 14:44:04 +0300 Subject: [PATCH 50/57] feat(blockifier): panic or saturate Fee arithmetic depending on 'natural' source of values (#1268) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1268) --- .../blockifier/src/execution/entry_point.rs | 2 +- .../starknet_api/src/execution_resources.rs | 21 +++++++++++++------ crates/starknet_api/src/transaction.rs | 3 +++ 3 files changed, 19 insertions(+), 7 deletions(-) diff --git a/crates/blockifier/src/execution/entry_point.rs b/crates/blockifier/src/execution/entry_point.rs index 8c9cf87d795..7ec5662b37b 100644 --- a/crates/blockifier/src/execution/entry_point.rs +++ b/crates/blockifier/src/execution/entry_point.rs @@ -279,6 +279,7 @@ impl EntryPointExecutionContext { // transactions derive this value from the `max_fee`. let tx_gas_upper_bound = match tx_info { // Fee is a larger uint type than GasAmount, so we need to saturate the division. + // This is just a computation of an upper bound, so it's safe to saturate. TransactionInfo::Deprecated(context) => context.max_fee.saturating_div( block_info.gas_prices.get_l1_gas_price_by_fee_type(&tx_info.fee_type()), ), @@ -287,7 +288,6 @@ impl EntryPointExecutionContext { // Use saturating upper bound to avoid overflow. This is safe because the upper bound is // bounded above by the block's limit, which is a usize. - let upper_bound_u64 = if gas_per_step.is_zero() { u64::MAX } else { diff --git a/crates/starknet_api/src/execution_resources.rs b/crates/starknet_api/src/execution_resources.rs index c29ce281f9a..0e71baaf929 100644 --- a/crates/starknet_api/src/execution_resources.rs +++ b/crates/starknet_api/src/execution_resources.rs @@ -49,6 +49,10 @@ impl_from_uint_for_gas_amount!(u8, u16, u32, u64); impl GasAmount { pub const MAX: Self = Self(u64::MAX); + pub fn checked_add(self, rhs: Self) -> Option { + self.0.checked_add(rhs.0).map(Self) + } + pub fn saturating_add(self, rhs: Self) -> Self { self.0.saturating_add(rhs.0).into() } @@ -142,21 +146,26 @@ impl GasVector { /// X non-data-related gas consumption and Y bytes of data, in non-blob mode, would /// cost (X + 16*Y) units of gas. Applying the discount ratio to the data-related /// summand, we get total_gas = (X + Y * DGP / GP). - /// If this function is called with kzg_flag==false, then l1_data_gas==0, and this dicount + /// If this function is called with kzg_flag==false, then l1_data_gas==0, and this discount /// function does nothing. + /// Panics on overflow. pub fn to_discounted_l1_gas(&self, gas_prices: &GasPriceVector) -> GasAmount { let l1_data_gas_fee = self.l1_data_gas.nonzero_saturating_mul(gas_prices.l1_data_gas_price); let l1_data_gas_in_l1_gas_units = l1_data_gas_fee.checked_div_ceil(gas_prices.l1_gas_price).unwrap_or_else(|| { - log::warn!( + panic!( "Discounted L1 gas cost overflowed: division of L1 data fee ({}) by regular \ L1 gas price ({}) resulted in overflow.", - l1_data_gas_fee, - gas_prices.l1_gas_price + l1_data_gas_fee, gas_prices.l1_gas_price ); - GasAmount::MAX }); - self.l1_gas.saturating_add(l1_data_gas_in_l1_gas_units) + self.l1_gas.checked_add(l1_data_gas_in_l1_gas_units).unwrap_or_else(|| { + panic!( + "Overflow while computing discounted L1 gas: L1 gas ({}) + L1 data gas in L1 gas \ + units ({}) resulted in overflow.", + self.l1_gas, l1_data_gas_in_l1_gas_units + ) + }) } } diff --git a/crates/starknet_api/src/transaction.rs b/crates/starknet_api/src/transaction.rs index a3d3e28e0bc..8008885b4df 100644 --- a/crates/starknet_api/src/transaction.rs +++ b/crates/starknet_api/src/transaction.rs @@ -1108,6 +1108,9 @@ impl ValidResourceBounds { } } + /// Returns the maximum possible fee that can be charged for the transaction. + /// The computation is saturating, meaning that if the result is larger than the maximum + /// possible fee, the maximum possible fee is returned. pub fn max_possible_fee(&self) -> Fee { match self { ValidResourceBounds::L1Gas(l1_bounds) => { From 30d2dcfaa5672b7721d0b562fdc38c3d5bc41736 Mon Sep 17 00:00:00 2001 From: Elin Date: Thu, 10 Oct 2024 14:45:45 +0300 Subject: [PATCH 51/57] fix(mempool): move starknet-core-types to dev-dependencies (#1287) --- crates/mempool_infra/Cargo.toml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/crates/mempool_infra/Cargo.toml b/crates/mempool_infra/Cargo.toml index a083e450f3f..903fcf2268b 100644 --- a/crates/mempool_infra/Cargo.toml +++ b/crates/mempool_infra/Cargo.toml @@ -18,14 +18,13 @@ hyper = { workspace = true, features = ["client", "http2", "server", "tcp"] } papyrus_config.workspace = true rstest.workspace = true serde = { workspace = true, features = ["derive"] } -starknet-types-core.workspace = true thiserror.workspace = true tokio = { workspace = true, features = ["macros", "rt-multi-thread"] } tracing.workspace = true tracing-subscriber = { workspace = true, features = ["env-filter"] } validator.workspace = true - [dev-dependencies] assert_matches.workspace = true pretty_assertions.workspace = true +starknet-types-core.workspace = true From efbdf05716f390cf9d0325d58afbb3bc1c52b0f3 Mon Sep 17 00:00:00 2001 From: dorimedini-starkware Date: Thu, 10 Oct 2024 14:52:08 +0300 Subject: [PATCH 52/57] feat(blockifier): saturate block step bound in max_steps (#1289) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This change is [Reviewable](https://reviewable.io/reviews/starkware-libs/sequencer/1289) --- .../blockifier/src/execution/entry_point.rs | 19 ++++++++----------- 1 file changed, 8 insertions(+), 11 deletions(-) diff --git a/crates/blockifier/src/execution/entry_point.rs b/crates/blockifier/src/execution/entry_point.rs index 7ec5662b37b..9abdaa3ed5d 100644 --- a/crates/blockifier/src/execution/entry_point.rs +++ b/crates/blockifier/src/execution/entry_point.rs @@ -257,17 +257,14 @@ impl EntryPointExecutionContext { let TransactionContext { block_context, tx_info } = tx_context; let BlockContext { block_info, versioned_constants, .. } = block_context; let block_upper_bound = match mode { - // TODO(Ori, 1/2/2024): Write an indicative expect message explaining why the conversion - // works. - ExecutionMode::Validate => versioned_constants - .validate_max_n_steps - .try_into() - .expect("Failed to convert validate_max_n_steps (u32) to usize."), - ExecutionMode::Execute => versioned_constants - .invoke_tx_max_n_steps - .try_into() - .expect("Failed to convert invoke_tx_max_n_steps (u32) to usize."), - }; + ExecutionMode::Validate => versioned_constants.validate_max_n_steps, + ExecutionMode::Execute => versioned_constants.invoke_tx_max_n_steps, + } + .try_into() + .unwrap_or_else(|error| { + log::warn!("Failed to convert global step limit to to usize: {error}."); + usize::MAX + }); if !limit_steps_by_resources || !tx_info.enforce_fee() { return block_upper_bound; From 212f0faea7cc4667dbe91e039d2b58261242915d Mon Sep 17 00:00:00 2001 From: matan-starkware <97523054+matan-starkware@users.noreply.github.com> Date: Thu, 10 Oct 2024 15:06:20 +0300 Subject: [PATCH 53/57] feat(consensus): add remaining API implementations to sequencer context (#1196) --- .../src/papyrus_consensus_context.rs | 2 +- .../src/sequencer_consensus_context.rs | 46 +++++++++++++------ .../src/sequencer_consensus_context_test.rs | 3 +- 3 files changed, 36 insertions(+), 15 deletions(-) diff --git a/crates/sequencing/papyrus_consensus_orchestrator/src/papyrus_consensus_context.rs b/crates/sequencing/papyrus_consensus_orchestrator/src/papyrus_consensus_context.rs index 386dce41b3b..2fb0d93e843 100644 --- a/crates/sequencing/papyrus_consensus_orchestrator/src/papyrus_consensus_context.rs +++ b/crates/sequencing/papyrus_consensus_orchestrator/src/papyrus_consensus_context.rs @@ -224,7 +224,7 @@ impl ConsensusContext for PapyrusConsensusContext { } fn proposer(&self, _height: BlockNumber, _round: Round) -> ValidatorId { - *self.validators.first().expect("validators should have at least 2 validators") + *self.validators.first().expect("there should be at least one validator") } async fn broadcast(&mut self, message: ConsensusMessage) -> Result<(), ConsensusError> { diff --git a/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context.rs b/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context.rs index 95898bdddb2..7d305d6516f 100644 --- a/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context.rs +++ b/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context.rs @@ -12,6 +12,7 @@ use std::time::Duration; use async_trait::async_trait; use futures::channel::{mpsc, oneshot}; use futures::sink::SinkExt; +use futures::stream::StreamExt; use papyrus_consensus::types::{ ConsensusContext, ConsensusError, @@ -30,7 +31,7 @@ use starknet_batcher_types::batcher_types::{ }; use starknet_batcher_types::communication::BatcherClient; use starknet_consensus_manager_types::consensus_manager_types::ProposalId; -use tracing::{debug, debug_span, warn, Instrument}; +use tracing::{debug, debug_span, info, warn, Instrument}; type HeightToIdToContent = BTreeMap>>; @@ -40,6 +41,7 @@ const CHANNEL_SIZE: usize = 5000; pub struct SequencerConsensusContext { batcher: Arc, + validators: Vec, // Proposal building/validating returns immediately, leaving the actual processing to a spawned // task. The spawned task processes the proposal asynchronously and updates the // valid_proposals map upon completion, ensuring consistency across tasks. @@ -51,9 +53,10 @@ pub struct SequencerConsensusContext { } impl SequencerConsensusContext { - pub fn new(batcher: Arc) -> Self { + pub fn new(batcher: Arc, num_validators: u64) -> Self { Self { batcher, + validators: (0..num_validators).map(ValidatorId::from).collect(), valid_proposals: Arc::new(Mutex::new(HeightToIdToContent::new())), proposal_id: 0, } @@ -131,32 +134,49 @@ impl ConsensusContext for SequencerConsensusContext { } async fn validators(&self, _height: BlockNumber) -> Vec { - todo!() + self.validators.clone() } fn proposer(&self, _height: BlockNumber, _round: Round) -> ValidatorId { - todo!() + *self.validators.first().expect("there should be at least one validator") } - async fn broadcast(&mut self, _message: ConsensusMessage) -> Result<(), ConsensusError> { - todo!() + async fn broadcast(&mut self, message: ConsensusMessage) -> Result<(), ConsensusError> { + debug!("No-op broadcasting message: {message:?}"); + Ok(()) } async fn propose( &self, - _init: ProposalInit, - _content_receiver: mpsc::Receiver, - _fin_receiver: oneshot::Receiver, + init: ProposalInit, + mut content_receiver: mpsc::Receiver, + fin_receiver: oneshot::Receiver, ) -> Result<(), ConsensusError> { - todo!() + // Spawn a task to keep receivers alive. + tokio::spawn(async move { + while content_receiver.next().await.is_some() {} + let fin = fin_receiver.await.expect("Failed to receive fin"); + debug!("No-op propose message: {init:?} {fin:?}"); + }); + Ok(()) } async fn decision_reached( &mut self, - _block: ProposalContentId, - _precommits: Vec, + block: ProposalContentId, + precommits: Vec, ) -> Result<(), ConsensusError> { - todo!() + let height = precommits[0].height; + info!("Finished consensus for height: {height}. Agreed on block: {:}", block); + + // TODO(matan): Broadcast the decision to the network. + + let mut proposals = self + .valid_proposals + .lock() + .expect("Lock on active proposals was poisoned due to a previous panic"); + proposals.retain(|&h, _| h > BlockNumber(height)); + Ok(()) } } diff --git a/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context_test.rs b/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context_test.rs index 7e5d28f6015..08f1b718f85 100644 --- a/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context_test.rs +++ b/crates/sequencing/papyrus_consensus_orchestrator/src/sequencer_consensus_context_test.rs @@ -23,6 +23,7 @@ use crate::sequencer_consensus_context::SequencerConsensusContext; const TIMEOUT: Duration = Duration::from_millis(100); const TX_COMMITMENT: TransactionCommitment = TransactionCommitment(Felt::ZERO); +const NUM_VALIDATORS: u64 = 4; lazy_static! { static ref TX_BATCH: Vec = vec![generate_invoke_tx(Felt::THREE)]; @@ -59,7 +60,7 @@ async fn build_proposal() { }), }) }); - let mut context = SequencerConsensusContext::new(Arc::new(batcher)); + let mut context = SequencerConsensusContext::new(Arc::new(batcher), NUM_VALIDATORS); let (mut content_receiver, fin_receiver) = context.build_proposal(BlockNumber(0), TIMEOUT).await; assert_eq!(content_receiver.next().await, Some(TX_BATCH.clone())); From 310ee6ed182d25c53297eeb4ff6982965f004e4d Mon Sep 17 00:00:00 2001 From: Elin Date: Thu, 10 Oct 2024 15:12:22 +0300 Subject: [PATCH 54/57] refactor(mempool_test_utils): remove create_resource_bounds_mapping (#1299) --- .../stateless_transaction_validator_test.rs | 38 +++++++++---------- .../src/starknet_api_test_utils.rs | 23 +++-------- 2 files changed, 22 insertions(+), 39 deletions(-) diff --git a/crates/gateway/src/stateless_transaction_validator_test.rs b/crates/gateway/src/stateless_transaction_validator_test.rs index 9d6475b2854..4dd52db0e84 100644 --- a/crates/gateway/src/stateless_transaction_validator_test.rs +++ b/crates/gateway/src/stateless_transaction_validator_test.rs @@ -4,7 +4,6 @@ use std::vec; use assert_matches::assert_matches; use mempool_test_utils::declare_tx_args; use mempool_test_utils::starknet_api_test_utils::{ - create_resource_bounds_mapping, rpc_declare_tx, rpc_tx_for_testing, zero_resource_bounds_mapping, @@ -73,11 +72,10 @@ fn default_validator_config_for_testing() -> &'static StatelessTransactionValida validate_non_zero_l2_gas_fee: false, ..default_validator_config_for_testing().clone() }, - create_resource_bounds_mapping( - NON_EMPTY_RESOURCE_BOUNDS, - ResourceBounds::default(), - ResourceBounds::default(), - ), + AllResourceBounds { + l1_gas: NON_EMPTY_RESOURCE_BOUNDS, + ..Default::default() + }, calldata![], TransactionSignature::default() )] @@ -87,11 +85,10 @@ fn default_validator_config_for_testing() -> &'static StatelessTransactionValida validate_non_zero_l2_gas_fee: true, ..default_validator_config_for_testing().clone() }, - create_resource_bounds_mapping( - ResourceBounds::default(), - NON_EMPTY_RESOURCE_BOUNDS, - ResourceBounds::default(), - ), + AllResourceBounds { + l2_gas: NON_EMPTY_RESOURCE_BOUNDS, + ..Default::default() + }, calldata![], TransactionSignature::default() )] @@ -101,11 +98,11 @@ fn default_validator_config_for_testing() -> &'static StatelessTransactionValida validate_non_zero_l2_gas_fee: true, ..default_validator_config_for_testing().clone() }, - create_resource_bounds_mapping( - NON_EMPTY_RESOURCE_BOUNDS, - NON_EMPTY_RESOURCE_BOUNDS, - ResourceBounds::default(), - ), + AllResourceBounds { + l1_gas: NON_EMPTY_RESOURCE_BOUNDS, + l2_gas: NON_EMPTY_RESOURCE_BOUNDS, + ..Default::default() + }, calldata![], TransactionSignature::default() )] @@ -159,11 +156,10 @@ fn test_positive_flow( validate_non_zero_l2_gas_fee: true, ..default_validator_config_for_testing().clone() }, - create_resource_bounds_mapping( - NON_EMPTY_RESOURCE_BOUNDS, - ResourceBounds::default(), - ResourceBounds::default(), - ), + AllResourceBounds { + l1_gas: NON_EMPTY_RESOURCE_BOUNDS, + ..Default::default() + }, StatelessTransactionValidatorError::ZeroResourceBounds{ resource: Resource::L2Gas, resource_bounds: ResourceBounds::default() } diff --git a/crates/mempool_test_utils/src/starknet_api_test_utils.rs b/crates/mempool_test_utils/src/starknet_api_test_utils.rs index 89174e51024..cf1557f343f 100644 --- a/crates/mempool_test_utils/src/starknet_api_test_utils.rs +++ b/crates/mempool_test_utils/src/starknet_api_test_utils.rs @@ -101,38 +101,25 @@ pub fn rpc_tx_for_testing( pub const NON_EMPTY_RESOURCE_BOUNDS: ResourceBounds = ResourceBounds { max_amount: GasAmount(1), max_price_per_unit: GasPrice(1) }; -// TODO(Nimrod): Delete this function. -pub fn create_resource_bounds_mapping( - l1_resource_bounds: ResourceBounds, - l2_resource_bounds: ResourceBounds, - l1_data_resource_bounds: ResourceBounds, -) -> AllResourceBounds { - AllResourceBounds { - l1_gas: l1_resource_bounds, - l2_gas: l2_resource_bounds, - l1_data_gas: l1_data_resource_bounds, - } -} - pub fn zero_resource_bounds_mapping() -> AllResourceBounds { AllResourceBounds::default() } pub fn test_resource_bounds_mapping() -> AllResourceBounds { - create_resource_bounds_mapping( - ResourceBounds { + AllResourceBounds { + l1_gas: ResourceBounds { max_amount: GasAmount(VALID_L1_GAS_MAX_AMOUNT), max_price_per_unit: GasPrice(VALID_L1_GAS_MAX_PRICE_PER_UNIT), }, - ResourceBounds { + l2_gas: ResourceBounds { max_amount: GasAmount(VALID_L2_GAS_MAX_AMOUNT), max_price_per_unit: GasPrice(VALID_L2_GAS_MAX_PRICE_PER_UNIT), }, - ResourceBounds { + l1_data_gas: ResourceBounds { max_amount: GasAmount(VALID_L1_DATA_GAS_MAX_AMOUNT), max_price_per_unit: GasPrice(VALID_L1_DATA_GAS_MAX_PRICE_PER_UNIT), }, - ) + } } pub fn test_valid_resource_bounds() -> ValidResourceBounds { From 1aec043b458fc8613ddc736c664d46d285e40a35 Mon Sep 17 00:00:00 2001 From: aner-starkware <147302140+aner-starkware@users.noreply.github.com> Date: Thu, 10 Oct 2024 15:55:28 +0300 Subject: [PATCH 55/57] build(blockifier_reexecution): get all txs (#1293) --- .../src/state_reader/test_state_reader.rs | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/crates/blockifier_reexecution/src/state_reader/test_state_reader.rs b/crates/blockifier_reexecution/src/state_reader/test_state_reader.rs index 75ecce90e56..66d5129de66 100644 --- a/crates/blockifier_reexecution/src/state_reader/test_state_reader.rs +++ b/crates/blockifier_reexecution/src/state_reader/test_state_reader.rs @@ -12,7 +12,7 @@ use serde_json::{json, to_value}; use starknet_api::block::BlockNumber; use starknet_api::core::{ClassHash, CompiledClassHash, ContractAddress, Nonce}; use starknet_api::state::StorageKey; -use starknet_api::transaction::Transaction; +use starknet_api::transaction::{Transaction, TransactionHash}; use starknet_core::types::ContractClass as StarknetContractClass; use starknet_core::types::ContractClass::{Legacy, Sierra}; use starknet_gateway::config::RpcStateReaderConfig; @@ -145,14 +145,15 @@ impl TestStateReader { Ok(contract_class) } - pub fn get_all_txs_in_block(&self) -> StateResult> { + pub fn get_all_txs_in_block(&self) -> StateResult> { // TODO(Aviv): Use batch request to get all txs in a block. - let txs: Vec<_> = self - .get_tx_hashes()? + self.get_tx_hashes()? .iter() - .map(|tx_hash| self.get_tx_by_hash(tx_hash)) - .collect::>()?; - Ok(txs) + .map(|tx_hash| match self.get_tx_by_hash(tx_hash) { + Err(error) => Err(error), + Ok(tx) => Ok((tx, TransactionHash(Felt::from_hex_unchecked(tx_hash)))), + }) + .collect::>() } pub fn get_versioned_constants(&self) -> StateResult<&'static VersionedConstants> { From 5a21cba5848fec43d50c9e0219b38237ef945e63 Mon Sep 17 00:00:00 2001 From: avivg-starkware Date: Thu, 10 Oct 2024 16:55:43 +0300 Subject: [PATCH 56/57] fix(config): limit concurrency to prevent 'cargo test/build' crash due to excessive memory use (#1259) --- .cargo/config.toml | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/.cargo/config.toml b/.cargo/config.toml index eb8a14bd9c4..f12746cc84d 100644 --- a/.cargo/config.toml +++ b/.cargo/config.toml @@ -2,3 +2,11 @@ LLVM_SYS_181_PREFIX = "/usr/lib/llvm-18/" MLIR_SYS_180_PREFIX = "/usr/lib/llvm-18/" TABLEGEN_180_PREFIX = "/usr/lib/llvm-18/" + +# Limit concurrency to prevent crash during "cargo build" due to excessive memory usage. Should be removed in the future. Slows down performance. +[build] +jobs = 8 + +# Limit concurrency to prevent crash during "cargo test" due to excessive memory usage. Should be removed in the future. Slows down performance. +[test] +jobs = 8 From ac479c5c36b58d843f12b4efb65fd6645acfe9ce Mon Sep 17 00:00:00 2001 From: Rodrigo Date: Thu, 10 Oct 2024 10:18:46 -0400 Subject: [PATCH 57/57] feat(blockifier): add `NativeSyscallHandler` (#1240) * feat: add native syscall handler * fix: compilation error * refactor: native syscall handler * refactor: move update_remainng_gas out of SyscallHandler impl * fix: restore concurrency in main workflow * refactor: unwrap -> expect in native gas withdraw * chore: restore rebase unintended changes --- crates/blockifier/src/execution/native.rs | 4 + .../src/execution/native/syscall_handler.rs | 328 ++++++++++++++++++ .../blockifier/src/execution/native/utils.rs | 39 +++ .../src/execution/native/utils_test.rs | 44 +++ 4 files changed, 415 insertions(+) create mode 100644 crates/blockifier/src/execution/native/syscall_handler.rs create mode 100644 crates/blockifier/src/execution/native/utils_test.rs diff --git a/crates/blockifier/src/execution/native.rs b/crates/blockifier/src/execution/native.rs index b5614dd8233..7c3dd35b219 100644 --- a/crates/blockifier/src/execution/native.rs +++ b/crates/blockifier/src/execution/native.rs @@ -1 +1,5 @@ +pub mod syscall_handler; pub mod utils; + +#[cfg(test)] +pub mod utils_test; diff --git a/crates/blockifier/src/execution/native/syscall_handler.rs b/crates/blockifier/src/execution/native/syscall_handler.rs new file mode 100644 index 00000000000..806abbc7b13 --- /dev/null +++ b/crates/blockifier/src/execution/native/syscall_handler.rs @@ -0,0 +1,328 @@ +use std::collections::HashSet; +use std::hash::RandomState; + +use cairo_native::starknet::{ + ExecutionInfo, + ExecutionInfoV2, + Secp256k1Point, + Secp256r1Point, + StarknetSyscallHandler, + SyscallResult, + U256, +}; +use cairo_vm::vm::runners::cairo_runner::ExecutionResources; +use starknet_api::core::{ContractAddress, EntryPointSelector}; +use starknet_api::state::StorageKey; +use starknet_types_core::felt::Felt; + +use crate::execution::call_info::{CallInfo, OrderedEvent, OrderedL2ToL1Message, Retdata}; +use crate::execution::entry_point::{CallEntryPoint, EntryPointExecutionContext}; +use crate::execution::execution_utils::update_remaining_gas; +use crate::execution::native::utils::encode_str_as_felts; +use crate::execution::syscalls::hint_processor::OUT_OF_GAS_ERROR; +use crate::state::state_api::State; + +pub struct NativeSyscallHandler<'state> { + // Input for execution. + pub state: &'state mut dyn State, + pub resources: &'state mut ExecutionResources, + pub context: &'state mut EntryPointExecutionContext, + + // Call information. + pub caller_address: ContractAddress, + pub contract_address: ContractAddress, + pub entry_point_selector: Felt, + + // Execution results. + pub events: Vec, + pub l2_to_l1_messages: Vec, + pub inner_calls: Vec, + + // Additional information gathered during execution. + pub read_values: Vec, + pub accessed_keys: HashSet, +} + +impl<'state> NativeSyscallHandler<'state> { + pub fn new( + state: &'state mut dyn State, + caller_address: ContractAddress, + contract_address: ContractAddress, + entry_point_selector: EntryPointSelector, + resources: &'state mut ExecutionResources, + context: &'state mut EntryPointExecutionContext, + ) -> NativeSyscallHandler<'state> { + NativeSyscallHandler { + state, + caller_address, + contract_address, + entry_point_selector: entry_point_selector.0, + resources, + context, + events: Vec::new(), + l2_to_l1_messages: Vec::new(), + inner_calls: Vec::new(), + read_values: Vec::new(), + accessed_keys: HashSet::new(), + } + } + + #[allow(dead_code)] + fn execute_inner_call( + &mut self, + entry_point: CallEntryPoint, + remaining_gas: &mut u128, + ) -> SyscallResult { + let call_info = entry_point + .execute(self.state, self.resources, self.context) + .map_err(|e| encode_str_as_felts(&e.to_string()))?; + let retdata = call_info.execution.retdata.clone(); + + if call_info.execution.failed { + // In VM it's wrapped into `SyscallExecutionError::SyscallError`. + return Err(retdata.0.clone()); + } + + native_update_remaining_gas(remaining_gas, &call_info); + + self.inner_calls.push(call_info); + + Ok(retdata) + } + + // Handles gas related logic when executing a syscall. Required because Native calls the + // syscalls directly unlike the VM where the `execute_syscall` method perform this operation + // first. + #[allow(dead_code)] + fn substract_syscall_gas_cost( + &mut self, + remaining_gas: &mut u128, + syscall_gas_cost: u64, + ) -> SyscallResult<()> { + // Refund `SYSCALL_BASE_GAS_COST` as it was pre-charged. + let required_gas = + u128::from(syscall_gas_cost - self.context.gas_costs().syscall_base_gas_cost); + + if *remaining_gas < required_gas { + // Out of gas failure. + return Err(vec![ + Felt::from_hex(OUT_OF_GAS_ERROR) + .expect("Failed to parse OUT_OF_GAS_ERROR hex string"), + ]); + } + + *remaining_gas -= required_gas; + + Ok(()) + } +} + +impl<'state> StarknetSyscallHandler for &mut NativeSyscallHandler<'state> { + fn get_block_hash( + &mut self, + _block_number: u64, + _remaining_gas: &mut u128, + ) -> SyscallResult { + todo!("Implement get_block_hash syscall."); + } + + fn get_execution_info(&mut self, _remaining_gas: &mut u128) -> SyscallResult { + todo!("Implement get_execution_info syscall."); + } + + fn get_execution_info_v2( + &mut self, + _remaining_gas: &mut u128, + ) -> SyscallResult { + todo!("Implement get_execution_info_v2 syscall."); + } + + fn deploy( + &mut self, + _class_hash: Felt, + _contract_address_salt: Felt, + _calldata: &[Felt], + _deploy_from_zero: bool, + _remaining_gas: &mut u128, + ) -> SyscallResult<(Felt, Vec)> { + todo!("Implement deploy syscall."); + } + + fn replace_class(&mut self, _class_hash: Felt, _remaining_gas: &mut u128) -> SyscallResult<()> { + todo!("Implement replace_class syscall."); + } + + fn library_call( + &mut self, + _class_hash: Felt, + _function_selector: Felt, + _calldata: &[Felt], + _remaining_gas: &mut u128, + ) -> SyscallResult> { + todo!("Implement library_call syscall."); + } + + fn call_contract( + &mut self, + _address: Felt, + _entry_point_selector: Felt, + _calldata: &[Felt], + _remaining_gas: &mut u128, + ) -> SyscallResult> { + todo!("Implement call_contract syscall."); + } + + fn storage_read( + &mut self, + _address_domain: u32, + _address: Felt, + _remaining_gas: &mut u128, + ) -> SyscallResult { + todo!("Implement storage_read syscall."); + } + + fn storage_write( + &mut self, + _address_domain: u32, + _address: Felt, + _value: Felt, + _remaining_gas: &mut u128, + ) -> SyscallResult<()> { + todo!("Implement storage_write syscall."); + } + + fn emit_event( + &mut self, + _keys: &[Felt], + _data: &[Felt], + _remaining_gas: &mut u128, + ) -> SyscallResult<()> { + todo!("Implement emit_event syscall."); + } + + fn send_message_to_l1( + &mut self, + _to_address: Felt, + _payload: &[Felt], + _remaining_gas: &mut u128, + ) -> SyscallResult<()> { + todo!("Implement send_message_to_l1 syscall."); + } + + fn keccak(&mut self, _input: &[u64], _remaining_gas: &mut u128) -> SyscallResult { + todo!("Implement keccak syscall."); + } + + fn secp256k1_new( + &mut self, + _x: U256, + _y: U256, + _remaining_gas: &mut u128, + ) -> SyscallResult> { + todo!("Implement secp256k1_new syscall."); + } + + fn secp256k1_add( + &mut self, + _p0: Secp256k1Point, + _p1: Secp256k1Point, + _remaining_gas: &mut u128, + ) -> SyscallResult { + todo!("Implement secp256k1_add syscall."); + } + + fn secp256k1_mul( + &mut self, + _p: Secp256k1Point, + _m: U256, + _remaining_gas: &mut u128, + ) -> SyscallResult { + todo!("Implement secp256k1_mul syscall."); + } + + fn secp256k1_get_point_from_x( + &mut self, + _x: U256, + _y_parity: bool, + _remaining_gas: &mut u128, + ) -> SyscallResult> { + todo!("Implement secp256k1_get_point_from_x syscall."); + } + + fn secp256k1_get_xy( + &mut self, + _p: Secp256k1Point, + _remaining_gas: &mut u128, + ) -> SyscallResult<(U256, U256)> { + todo!("Implement secp256k1_get_xy syscall."); + } + + fn secp256r1_new( + &mut self, + _x: U256, + _y: U256, + _remaining_gas: &mut u128, + ) -> SyscallResult> { + todo!("Implement secp256r1_new syscall."); + } + + fn secp256r1_add( + &mut self, + _p0: Secp256r1Point, + _p1: Secp256r1Point, + _remaining_gas: &mut u128, + ) -> SyscallResult { + todo!("Implement secp256r1_add syscall."); + } + + fn secp256r1_mul( + &mut self, + _p: Secp256r1Point, + _m: U256, + _remaining_gas: &mut u128, + ) -> SyscallResult { + todo!("Implement secp256r1_mul syscall."); + } + + fn secp256r1_get_point_from_x( + &mut self, + _x: U256, + _y_parity: bool, + _remaining_gas: &mut u128, + ) -> SyscallResult> { + todo!("Implement secp256r1_get_point_from_x syscall."); + } + + fn secp256r1_get_xy( + &mut self, + _p: Secp256r1Point, + _remaining_gas: &mut u128, + ) -> SyscallResult<(U256, U256)> { + todo!("Implement secp256r1_get_xy syscall."); + } + + fn sha256_process_block( + &mut self, + _prev_state: &[u32; 8], + _current_block: &[u32; 16], + _remaining_gas: &mut u128, + ) -> SyscallResult<[u32; 8]> { + todo!("Implement sha256_process_block syscall."); + } +} + +/// Wrapper function around [update_remaining_gas] which takes a u128 as an input, converts it to +/// u64 and uses [update_remaining_gas] to withdraw the right amount. Finally, updates the value +/// to which `remaining_gas` points to. +#[allow(dead_code)] +fn native_update_remaining_gas(remaining_gas: &mut u128, call_info: &CallInfo) { + // Create a new variable with converted type. + let mut remaining_gas_u64 = + u64::try_from(*remaining_gas).expect("Failed to convert gas to u64."); + + // Pass the reference to the function. + update_remaining_gas(&mut remaining_gas_u64, call_info); + + // Change the remaining gas value. + *remaining_gas = u128::from(remaining_gas_u64); +} diff --git a/crates/blockifier/src/execution/native/utils.rs b/crates/blockifier/src/execution/native/utils.rs index addcbcc3adc..2aeb969e9d6 100644 --- a/crates/blockifier/src/execution/native/utils.rs +++ b/crates/blockifier/src/execution/native/utils.rs @@ -1,4 +1,5 @@ use cairo_lang_starknet_classes::contract_class::ContractEntryPoint; +use itertools::Itertools; use starknet_api::core::EntryPointSelector; use starknet_types_core::felt::Felt; @@ -7,3 +8,41 @@ pub fn contract_entrypoint_to_entrypoint_selector( ) -> EntryPointSelector { EntryPointSelector(Felt::from(&entrypoint.selector)) } + +pub fn encode_str_as_felts(msg: &str) -> Vec { + const CHUNK_SIZE: usize = 32; + + let data = msg.as_bytes().chunks(CHUNK_SIZE - 1); + let mut encoding = vec![Felt::default(); data.len()]; + for (i, data_chunk) in data.enumerate() { + let mut chunk = [0_u8; CHUNK_SIZE]; + chunk[1..data_chunk.len() + 1].copy_from_slice(data_chunk); + encoding[i] = Felt::from_bytes_be(&chunk); + } + encoding +} + +// Todo(rodrigo): This is an opinionated way of interpretting error messages. It's ok for now but I +// think it can be improved; (for example) trying to make the output similar to a Cairo VM panic +pub fn decode_felts_as_str(encoding: &[Felt]) -> String { + let bytes_err: Vec<_> = + encoding.iter().flat_map(|felt| felt.to_bytes_be()[1..32].to_vec()).collect(); + + match String::from_utf8(bytes_err) { + // If the string is utf8 make sure it is not prefixed by no null chars. Null chars in + // between can still happen + Ok(s) => s.trim_matches('\0').to_owned(), + // If the string is non-utf8 overall, try to decode them as utf8 chunks of it and keep the + // original bytes for the non-utf8 chunks + Err(_) => { + let err_msgs = encoding + .iter() + .map(|felt| match String::from_utf8(felt.to_bytes_be()[1..32].to_vec()) { + Ok(s) => format!("{} ({})", s.trim_matches('\0'), felt), + Err(_) => felt.to_string(), + }) + .join(", "); + format!("[{}]", err_msgs) + } + } +} diff --git a/crates/blockifier/src/execution/native/utils_test.rs b/crates/blockifier/src/execution/native/utils_test.rs new file mode 100644 index 00000000000..bffd39b6ca9 --- /dev/null +++ b/crates/blockifier/src/execution/native/utils_test.rs @@ -0,0 +1,44 @@ +use cairo_lang_starknet_classes::contract_class::ContractEntryPoint; +use num_bigint::BigUint; +use pretty_assertions::assert_eq; +use starknet_api::core::EntryPointSelector; +use starknet_types_core::felt::Felt; + +use crate::execution::native::utils::{ + contract_entrypoint_to_entrypoint_selector, + decode_felts_as_str, + encode_str_as_felts, +}; + +#[test] +fn test_contract_entrypoint_to_entrypoint_selector() { + const NUM: u128 = 123; + + let entrypoint = ContractEntryPoint { selector: BigUint::from(NUM), function_idx: 0 }; + let expected_entrypoint_selector = EntryPointSelector(Felt::from(NUM)); + let actual_entrypoint_selector = contract_entrypoint_to_entrypoint_selector(&entrypoint); + + assert_eq!(actual_entrypoint_selector, expected_entrypoint_selector); +} + +#[test] +fn test_encode_decode_str() { + const STR: &str = "normal utf8 string:"; + + let encoded_felt_array = encode_str_as_felts(STR); + + let decoded_felt_array = decode_felts_as_str(encoded_felt_array.as_slice()); + + assert_eq!(&decoded_felt_array, STR); +} + +#[test] +fn test_decode_non_utf8_str() { + let v1 = Felt::from_dec_str("1234").unwrap(); + let v2_msg = "i am utf8"; + let v2 = Felt::from_bytes_be_slice(v2_msg.as_bytes()); + let v3 = Felt::from_dec_str("13299428").unwrap(); + let felts = [v1, v2, v3]; + + assert_eq!(decode_felts_as_str(&felts), format!("[{}, {} ({}), {}]", v1, v2_msg, v2, v3)) +}