From f5dce7ef360748a548d8136c146241fb4b912a48 Mon Sep 17 00:00:00 2001 From: Arun Jangra Date: Thu, 20 Jun 2024 20:17:44 +0530 Subject: [PATCH] feat: Declare V0 RPC call (#1617) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: ocdbytes Co-authored-by: Arun Jangra Co-authored-by: Timothée Delabrouille --- CHANGELOG.md | 1 + Cargo.lock | 57 +- crates/client/rpc-core/src/lib.rs | 8 + crates/client/rpc/Cargo.toml | 1 - crates/client/rpc/src/lib.rs | 85 +- crates/client/rpc/src/madara_routes.rs | 86 + crates/client/rpc/src/starknetrpcwrapper.rs | 10 +- .../client/starknet-block-import/Cargo.toml | 4 - crates/node/Cargo.toml | 4 - crates/pallets/starknet/Cargo.toml | 3 - .../pallets/starknet/runtime_api/Cargo.toml | 3 - crates/pallets/starknet/src/lib.rs | 18 + .../starknet/src/transaction_validation.rs | 1 + crates/primitives/simulations/Cargo.toml | 1 - crates/primitives/snos-output/Cargo.toml | 1 - .../src/from_broadcasted_transactions.rs | 119 +- crates/primitives/transactions/src/lib.rs | 20 +- starknet-rpc-test/Cargo.toml | 7 +- starknet-rpc-test/contracts/proxy.json | 60109 ++++++++++++++++ starknet-rpc-test/declareV0.rs | 61 + starknet-rpc-test/src/lib.rs | 2 +- starknet-test-utils/src/lib.rs | 2 +- 22 files changed, 60432 insertions(+), 171 deletions(-) create mode 100644 crates/client/rpc/src/madara_routes.rs create mode 100644 starknet-rpc-test/contracts/proxy.json create mode 100644 starknet-rpc-test/declareV0.rs diff --git a/CHANGELOG.md b/CHANGELOG.md index 22f97f514b..7a03580f6c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -8,6 +8,7 @@ ## v0.8.0 +- feat: Declare V0 RPC call - feat: add `TransactionFilter` to pallet-starknet `Config` - chore: remove `ignore` from `storage_changes_should_revert_on_transaction_revert` test diff --git a/Cargo.lock b/Cargo.lock index 5e130f9de5..a52405dd94 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4087,12 +4087,6 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" -[[package]] -name = "hexlit" -version = "0.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b6e75c860d4216ac53f9ac88b25c99eaedba075b3a7b2ed31f2adc51a74fffd" - [[package]] name = "hkdf" version = "0.12.3" @@ -5531,7 +5525,6 @@ dependencies = [ "jsonrpsee", "log", "madara-runtime", - "mc-commitment-state-diff", "mc-db", "mc-eth-client", "mc-genesis-data-provider", @@ -5545,7 +5538,6 @@ dependencies = [ "mp-digest-log", "mp-felt", "mp-starknet-inherent", - "num-bigint", "pallet-starknet", "pallet-starknet-runtime-api", "reqwest", @@ -5571,7 +5563,6 @@ dependencies = [ "sp-api", "sp-block-builder", "sp-blockchain", - "sp-consensus", "sp-consensus-aura", "sp-consensus-grandpa", "sp-core", @@ -5585,7 +5576,6 @@ dependencies = [ "substrate-build-script-utils", "substrate-frame-rpc-system", "substrate-prometheus-endpoint", - "thiserror", "try-runtime-cli", "url", ] @@ -5835,7 +5825,6 @@ dependencies = [ "sc-transaction-pool", "sc-transaction-pool-api", "serde", - "serde_json", "sp-api", "sp-arithmetic", "sp-blockchain", @@ -5881,11 +5870,9 @@ version = "0.8.0" dependencies = [ "async-trait", "blockifier", - "cairo-lang-starknet", "cairo-lang-starknet-classes", "cairo-lang-utils", "cairo-vm", - "hex", "log", "madara-runtime", "mc-db", @@ -5893,10 +5880,8 @@ dependencies = [ "mp-felt", "mp-transactions", "num-bigint", - "pallet-starknet", "pallet-starknet-runtime-api", "sc-consensus", - "sc-rpc-api", "serde_json", "sp-api", "sp-consensus", @@ -6215,14 +6200,12 @@ dependencies = [ "parity-scale-codec", "scale-info", "starknet-core", - "starknet_api", ] [[package]] name = "mp-snos-output" version = "0.8.0" dependencies = [ - "assert_matches", "hex", "mp-messages", "parity-scale-codec", @@ -6898,7 +6881,6 @@ dependencies = [ "cairo-vm", "frame-support", "frame-system", - "hexlit", "lazy_static", "log", "mp-block", @@ -6925,9 +6907,7 @@ dependencies = [ "sp-std", "starknet-core", "starknet-crypto 0.6.2", - "starknet-ff 0.3.7", "starknet_api", - "test-case", ] [[package]] @@ -6938,10 +6918,7 @@ dependencies = [ "mp-felt", "mp-simulations", "mp-starknet-inherent", - "parity-scale-codec", - "scale-info", "sp-api", - "sp-runtime", "starknet_api", ] @@ -10951,6 +10928,7 @@ dependencies = [ "async-trait", "env_logger 0.9.3", "flate2", + "mp-transactions", "reqwest", "rstest 0.18.2", "serde", @@ -11321,39 +11299,6 @@ version = "0.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3369f5ac52d5eb6ab48c6b4ffdc8efbcad6b89c765749064ba298f2c68a16a76" -[[package]] -name = "test-case" -version = "3.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb2550dd13afcd286853192af8601920d959b14c401fcece38071d53bf0768a8" -dependencies = [ - "test-case-macros", -] - -[[package]] -name = "test-case-core" -version = "3.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "adcb7fd841cd518e279be3d5a3eb0636409487998a4aff22f3de87b81e88384f" -dependencies = [ - "cfg-if", - "proc-macro2", - "quote", - "syn 2.0.39", -] - -[[package]] -name = "test-case-macros" -version = "3.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c89e72a01ed4c579669add59014b9a524d609c0c88c6a585ce37485879f6ffb" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.39", - "test-case-core", -] - [[package]] name = "thiserror" version = "1.0.55" diff --git a/crates/client/rpc-core/src/lib.rs b/crates/client/rpc-core/src/lib.rs index c72b0843e0..6f6c7e88db 100644 --- a/crates/client/rpc-core/src/lib.rs +++ b/crates/client/rpc-core/src/lib.rs @@ -9,6 +9,7 @@ mod tests; use jsonrpsee::core::RpcResult; use jsonrpsee::proc_macros::rpc; +use mp_transactions::BroadcastedDeclareTransactionV0; use serde::{Deserialize, Serialize}; use serde_with::serde_as; @@ -41,6 +42,13 @@ pub struct PredeployedAccountWithBalance { pub trait MadaraRpcApi: StarknetReadRpcApi { #[method(name = "predeployedAccounts")] fn predeployed_accounts(&self) -> RpcResult>; + + /// Submit a declare transaction for cairo 0 contract to be initialised with given address. + #[method(name = "addDeclareTransactionV0")] + async fn add_declare_transaction_v0( + &self, + params: BroadcastedDeclareTransactionV0, + ) -> RpcResult; } /// Starknet write rpc interface. diff --git a/crates/client/rpc/Cargo.toml b/crates/client/rpc/Cargo.toml index a062e8cb94..2bc4c75df1 100644 --- a/crates/client/rpc/Cargo.toml +++ b/crates/client/rpc/Cargo.toml @@ -45,7 +45,6 @@ mp-hashers = { workspace = true } mp-simulations = { workspace = true } mp-transactions = { workspace = true, features = ["client"] } serde = { workspace = true } -serde_json = { workspace = true } starknet-core = { workspace = true } starknet-ff = { workspace = true } starknet_api = { workspace = true } diff --git a/crates/client/rpc/src/lib.rs b/crates/client/rpc/src/lib.rs index 4065b278a3..64c0c6dd69 100644 --- a/crates/client/rpc/src/lib.rs +++ b/crates/client/rpc/src/lib.rs @@ -6,6 +6,7 @@ mod constants; mod errors; mod events; mod madara_backend_client; +mod madara_routes; mod runtime_api; pub mod starknetrpcwrapper; mod trace_api; @@ -17,7 +18,7 @@ use std::sync::Arc; use blockifier::transaction::account_transaction::AccountTransaction; use blockifier::transaction::objects::{ResourcesMapping, TransactionExecutionInfo}; -use blockifier::transaction::transactions::L1HandlerTransaction; +use blockifier::transaction::transactions::{DeclareTransaction, L1HandlerTransaction}; use errors::StarknetRpcApiError; use jsonrpsee::core::{async_trait, RpcResult}; use log::error; @@ -52,7 +53,7 @@ use sp_blockchain::HeaderBackend; use sp_core::H256; use sp_runtime::traits::{Block as BlockT, Header as HeaderT}; use sp_runtime::transaction_validity::InvalidTransaction; -use starknet_api::core::Nonce; +use starknet_api::core::{ClassHash, Nonce}; use starknet_api::hash::StarkFelt; use starknet_api::transaction::{Calldata, Fee, TransactionHash, TransactionVersion}; use starknet_core::types::{ @@ -68,7 +69,6 @@ use starknet_core::types::{ SimulationFlagForEstimateFee, StateDiff, StateUpdate, SyncStatus, SyncStatusType, Transaction, TransactionExecutionStatus, TransactionFinalityStatus, TransactionReceipt, }; -use starknet_core::utils::get_selector_from_name; use trace_api::get_previous_block_substrate_hash; use crate::constants::{MAX_EVENTS_CHUNK_SIZE, MAX_EVENTS_KEYS}; @@ -220,50 +220,49 @@ where } } -/// Taken from https://github.com/paritytech/substrate/blob/master/client/rpc/src/author/mod.rs#L78 -const TX_SOURCE: TransactionSource = TransactionSource::External; - -impl MadaraRpcApiServer for Starknet +impl Starknet where A: ChainApi + 'static, B: BlockT, + P: TransactionPool + 'static, BE: Backend + 'static, C: HeaderBackend + BlockBackend + StorageProvider + 'static, C: ProvideRuntimeApi, - G: GenesisProvider + Send + Sync + 'static, C::Api: StarknetRuntimeApi + ConvertTransactionRuntimeApi, - P: TransactionPool + 'static, + G: GenesisProvider + Send + Sync + 'static, H: HasherT + Send + Sync + 'static, { - fn predeployed_accounts(&self) -> RpcResult> { - let genesis_data = self.genesis_provider.load_genesis_data()?; - let block_id = BlockId::Tag(BlockTag::Latest); - let fee_token_address: FieldElement = genesis_data.eth_fee_token_address.0; + async fn declare_tx_common( + &self, + txn: DeclareTransaction, + ) -> Result<(TransactionHash, ClassHash), StarknetRpcApiError> { + let best_block_hash = self.get_best_block_hash(); + let current_block_hash = self.get_best_block_hash(); + let contract_class = self + .overrides + .for_block_hash(self.client.as_ref(), current_block_hash) + .contract_class_by_class_hash(current_block_hash, txn.class_hash()); - Ok(genesis_data - .predeployed_accounts - .into_iter() - .map(|account| { - let contract_address: FieldElement = account.contract_address.into(); - let balance_string = &self - .call( - FunctionCall { - contract_address: fee_token_address, - entry_point_selector: get_selector_from_name("balanceOf") - .expect("the provided method name should be a valid ASCII string."), - calldata: vec![contract_address], - }, - block_id, - ) - .expect("FunctionCall attributes should be correct.")[0]; - let balance = - Felt252Wrapper::from_hex_be(balance_string).expect("`balanceOf` should return a Felt").into(); - PredeployedAccountWithBalance { account, balance } - }) - .collect::>()) + if let Some(contract_class) = contract_class { + log::debug!("Contract class already exists: {:?}", contract_class); + return Err(StarknetRpcApiError::ClassAlreadyDeclared); + } + + let extrinsic = + self.convert_tx_to_extrinsic(best_block_hash, AccountTransaction::Declare(txn.clone())).unwrap(); + + let res = submit_extrinsic(self.pool.clone(), best_block_hash, extrinsic).await; + + match res { + Ok(_val) => Ok((txn.tx_hash, txn.class_hash())), + Err(e) => Err(e), + } } } +/// Taken from https://github.com/paritytech/substrate/blob/master/client/rpc/src/author/mod.rs#L78 +const TX_SOURCE: TransactionSource = TransactionSource::External; + #[async_trait] impl StarknetWriteRpcApiServer for Starknet where @@ -290,8 +289,6 @@ where &self, declare_transaction: BroadcastedDeclareTransaction, ) -> RpcResult { - let best_block_hash = self.get_best_block_hash(); - let opt_sierra_contract_class = if let BroadcastedDeclareTransaction::V2(ref tx) = declare_transaction { Some(flattened_sierra_to_sierra_contract_class(tx.contract_class.clone())) } else { @@ -304,22 +301,8 @@ where error!("Failed to convert BroadcastedDeclareTransaction to DeclareTransaction, error: {e}"); StarknetRpcApiError::InternalServerError })?; - let (class_hash, tx_hash) = (transaction.class_hash(), transaction.tx_hash()); - - let current_block_hash = self.get_best_block_hash(); - let contract_class = self - .overrides - .for_block_hash(self.client.as_ref(), current_block_hash) - .contract_class_by_class_hash(current_block_hash, class_hash); - if let Some(contract_class) = contract_class { - error!("Contract class already exists: {:?}", contract_class); - return Err(StarknetRpcApiError::ClassAlreadyDeclared.into()); - } - - let extrinsic = self.convert_tx_to_extrinsic(best_block_hash, AccountTransaction::Declare(transaction))?; - - submit_extrinsic(self.pool.clone(), best_block_hash, extrinsic).await?; + let (tx_hash, class_hash) = self.declare_tx_common(transaction).await?; if let Some(sierra_contract_class) = opt_sierra_contract_class { if let Some(e) = self.backend.sierra_classes().store_sierra_class(class_hash, sierra_contract_class).err() { diff --git a/crates/client/rpc/src/madara_routes.rs b/crates/client/rpc/src/madara_routes.rs new file mode 100644 index 0000000000..a9ab5ab730 --- /dev/null +++ b/crates/client/rpc/src/madara_routes.rs @@ -0,0 +1,86 @@ +use jsonrpsee::core::{async_trait, RpcResult}; +use log::error; +use mc_genesis_data_provider::GenesisProvider; +pub use mc_rpc_core::{ + Felt, MadaraRpcApiServer, PredeployedAccountWithBalance, StarknetReadRpcApiServer, StarknetTraceRpcApiServer, + StarknetWriteRpcApiServer, +}; +use mp_felt::Felt252Wrapper; +use mp_hashers::HasherT; +use mp_transactions::from_broadcasted_transactions::try_declare_tx_from_broadcasted_declare_tx_v0; +use mp_transactions::BroadcastedDeclareTransactionV0; +use pallet_starknet_runtime_api::{ConvertTransactionRuntimeApi, StarknetRuntimeApi}; +use sc_client_api::backend::Backend; +use sc_client_api::{BlockBackend, StorageProvider}; +use sc_transaction_pool::ChainApi; +use sc_transaction_pool_api::TransactionPool; +use sp_api::ProvideRuntimeApi; +use sp_blockchain::HeaderBackend; +use sp_runtime::traits::Block as BlockT; +use starknet_core::types::{BlockId, BlockTag, DeclareTransactionResult, FieldElement, FunctionCall}; +use starknet_core::utils::get_selector_from_name; + +use crate::errors::StarknetRpcApiError; +use crate::Starknet; + +#[async_trait] +impl MadaraRpcApiServer for Starknet +where + A: ChainApi + 'static, + B: BlockT, + BE: Backend + 'static, + C: HeaderBackend + BlockBackend + StorageProvider + 'static, + C: ProvideRuntimeApi, + G: GenesisProvider + Send + Sync + 'static, + C::Api: StarknetRuntimeApi + ConvertTransactionRuntimeApi, + P: TransactionPool + 'static, + H: HasherT + Send + Sync + 'static, +{ + fn predeployed_accounts(&self) -> RpcResult> { + let genesis_data = self.genesis_provider.load_genesis_data()?; + let block_id = BlockId::Tag(BlockTag::Latest); + let fee_token_address: FieldElement = genesis_data.eth_fee_token_address.0; + + Ok(genesis_data + .predeployed_accounts + .into_iter() + .map(|account| { + let contract_address: FieldElement = account.contract_address.into(); + let balance_string = &self + .call( + FunctionCall { + contract_address: fee_token_address, + entry_point_selector: get_selector_from_name("balanceOf") + .expect("the provided method name should be a valid ASCII string."), + calldata: vec![contract_address], + }, + block_id, + ) + .expect("FunctionCall attributes should be correct.")[0]; + let balance = + Felt252Wrapper::from_hex_be(balance_string).expect("`balanceOf` should return a Felt").into(); + PredeployedAccountWithBalance { account, balance } + }) + .collect::>()) + } + + async fn add_declare_transaction_v0( + &self, + declare_transaction: BroadcastedDeclareTransactionV0, + ) -> RpcResult { + let chain_id = Felt252Wrapper(self.chain_id()?.0); + + let transaction = + try_declare_tx_from_broadcasted_declare_tx_v0(declare_transaction, chain_id).map_err(|e| { + error!("Failed to convert BroadcastedDeclareTransactionV0 to DeclareTransaction, error: {e}"); + StarknetRpcApiError::InternalServerError + })?; + + let (tx_hash, class_hash) = self.declare_tx_common(transaction).await?; + + Ok(DeclareTransactionResult { + transaction_hash: Felt252Wrapper::from(tx_hash).into(), + class_hash: Felt252Wrapper::from(class_hash).into(), + }) + } +} diff --git a/crates/client/rpc/src/starknetrpcwrapper.rs b/crates/client/rpc/src/starknetrpcwrapper.rs index a2a778b9ce..bb3cba0a82 100644 --- a/crates/client/rpc/src/starknetrpcwrapper.rs +++ b/crates/client/rpc/src/starknetrpcwrapper.rs @@ -7,7 +7,7 @@ pub use mc_rpc_core::{ StarknetWriteRpcApiServer, }; use mp_hashers::HasherT; -use mp_transactions::TransactionStatus; +use mp_transactions::{BroadcastedDeclareTransactionV0, TransactionStatus}; use pallet_starknet_runtime_api::{ConvertTransactionRuntimeApi, StarknetRuntimeApi}; use sc_client_api::backend::{Backend, StorageProvider}; use sc_client_api::BlockBackend; @@ -36,6 +36,7 @@ impl Clone for StarknetRpcWrapper MadaraRpcApiServer for StarknetRpcWrapper where A: ChainApi + 'static, @@ -51,6 +52,13 @@ where fn predeployed_accounts(&self) -> RpcResult> { self.0.predeployed_accounts() } + + async fn add_declare_transaction_v0( + &self, + params: BroadcastedDeclareTransactionV0, + ) -> RpcResult { + self.0.add_declare_transaction_v0(params).await + } } #[async_trait] diff --git a/crates/client/starknet-block-import/Cargo.toml b/crates/client/starknet-block-import/Cargo.toml index 013ee0a0cb..5dd556c275 100644 --- a/crates/client/starknet-block-import/Cargo.toml +++ b/crates/client/starknet-block-import/Cargo.toml @@ -24,19 +24,15 @@ sp-runtime = { workspace = true } # Substrate client dependencies sc-consensus = { workspace = true } -sc-rpc-api = { workspace = true } # Starknet blockifier = { workspace = true } -cairo-lang-starknet = { workspace = true } cairo-lang-starknet-classes = { workspace = true } cairo-lang-utils = { workspace = true } cairo-vm = { workspace = true } -hex = { workspace = true } madara-runtime = { workspace = true } mc-db = { workspace = true } mc-rpc = { workspace = true } -pallet-starknet = { workspace = true } pallet-starknet-runtime-api = { workspace = true } starknet-core = { workspace = true } starknet_api = { workspace = true, features = [ diff --git a/crates/node/Cargo.toml b/crates/node/Cargo.toml index 58948f4c73..e7b51de228 100644 --- a/crates/node/Cargo.toml +++ b/crates/node/Cargo.toml @@ -25,10 +25,8 @@ async-trait = "0.1" clap = { workspace = true, features = ["derive"] } futures = { workspace = true, features = ["thread-pool"] } log = { workspace = true } -num-bigint = { workspace = true } serde = { workspace = true } sha3 = { workspace = true } -thiserror = { workspace = true } frame-system = { workspace = true } sc-basic-authorship = { workspace = true } @@ -46,7 +44,6 @@ sc-service = { workspace = true } sc-telemetry = { workspace = true } sc-transaction-pool = { workspace = true } sc-transaction-pool-api = { workspace = true } -sp-consensus = { workspace = true } sp-consensus-aura = { workspace = true } sp-consensus-grandpa = { workspace = true } sp-core = { workspace = true } @@ -77,7 +74,6 @@ substrate-frame-rpc-system = { workspace = true } frame-benchmarking = { workspace = true } frame-benchmarking-cli = { workspace = true } madara-runtime = { workspace = true, features = ["std"] } -mc-commitment-state-diff = { workspace = true } mc-db = { workspace = true } mc-eth-client = { workspace = true } mc-l1-gas-price = { workspace = true } diff --git a/crates/pallets/starknet/Cargo.toml b/crates/pallets/starknet/Cargo.toml index 902e3ff81b..582fd1adc8 100644 --- a/crates/pallets/starknet/Cargo.toml +++ b/crates/pallets/starknet/Cargo.toml @@ -58,11 +58,8 @@ cairo-lang-starknet-classes = { workspace = true, optional = true } [dev-dependencies] pallet-timestamp = { workspace = true } pretty_assertions = { workspace = true } -test-case = "3.1.0" lazy_static = "1.4.0" -hexlit = "0.5.5" assert_matches = "1.5.0" -starknet-ff = { workspace = true } project-root = "0.2.2" [features] diff --git a/crates/pallets/starknet/runtime_api/Cargo.toml b/crates/pallets/starknet/runtime_api/Cargo.toml index 0696932b79..93ab986633 100644 --- a/crates/pallets/starknet/runtime_api/Cargo.toml +++ b/crates/pallets/starknet/runtime_api/Cargo.toml @@ -22,7 +22,4 @@ blockifier = { workspace = true } starknet_api = { workspace = true } # Substrate -parity-scale-codec = { workspace = true, features = ["derive"] } -scale-info = { workspace = true, features = ["derive"] } sp-api = { workspace = true } -sp-runtime = { workspace = true } diff --git a/crates/pallets/starknet/src/lib.rs b/crates/pallets/starknet/src/lib.rs index 615603e01a..3b65d3239e 100644 --- a/crates/pallets/starknet/src/lib.rs +++ b/crates/pallets/starknet/src/lib.rs @@ -736,6 +736,24 @@ pub mod pallet { let transaction = Self::convert_runtime_calls_to_starknet_transaction(call.clone()) .map_err(|_| InvalidTransaction::Call)?; + + // Version 0 transaction does not have any nonce or validation rules. + match transaction { + Transaction::AccountTransaction(AccountTransaction::Declare(DeclareTransaction { tx, .. })) + if tx.version() == TransactionVersion::ZERO => + { + let sender_address: ContractAddress = Felt252Wrapper::from(tx.sender_address()).into(); + let nonce: Nonce = Felt252Wrapper::from(tx.nonce()).into(); + + return ValidTransaction::with_tag_prefix("starknet") + .priority(u64::MAX) + .longevity(T::TransactionLongevity::get()) + .propagate(true) + .and_provides((sender_address, nonce)) + .build(); + } + _ => {} + } // Important to store the nonce before the call to prevalidate, because the `handle_nonce` // function will increment it let transaction_nonce = get_transaction_nonce(&transaction); diff --git a/crates/pallets/starknet/src/transaction_validation.rs b/crates/pallets/starknet/src/transaction_validation.rs index b45bb77af5..c6a4ad2038 100644 --- a/crates/pallets/starknet/src/transaction_validation.rs +++ b/crates/pallets/starknet/src/transaction_validation.rs @@ -123,6 +123,7 @@ impl Pallet { AccountTransaction::DeployAccount(tx) => tx.contract_address, AccountTransaction::Invoke(tx) => tx.tx.sender_address(), }; + if address == sender_address && account_nonce == Nonce(StarkFelt::ZERO) && incoming_tx_nonce == Nonce(StarkFelt::ONE) diff --git a/crates/primitives/simulations/Cargo.toml b/crates/primitives/simulations/Cargo.toml index 310c370632..fc0eac38be 100644 --- a/crates/primitives/simulations/Cargo.toml +++ b/crates/primitives/simulations/Cargo.toml @@ -13,7 +13,6 @@ targets = ["x86_64-unknown-linux-gnu"] [dependencies] blockifier = { workspace = true } starknet-core = { workspace = true } -starknet_api = { workspace = true } # Optional dependencies parity-scale-codec = { workspace = true, optional = true } diff --git a/crates/primitives/snos-output/Cargo.toml b/crates/primitives/snos-output/Cargo.toml index 27ea97a5cc..92370c089d 100644 --- a/crates/primitives/snos-output/Cargo.toml +++ b/crates/primitives/snos-output/Cargo.toml @@ -17,7 +17,6 @@ starknet_api = { workspace = true } [dev-dependencies] pretty_assertions = { workspace = true } -assert_matches = "1.5.0" hex = "*" [features] diff --git a/crates/primitives/transactions/src/from_broadcasted_transactions.rs b/crates/primitives/transactions/src/from_broadcasted_transactions.rs index d6ef214ac5..d14e841edc 100644 --- a/crates/primitives/transactions/src/from_broadcasted_transactions.rs +++ b/crates/primitives/transactions/src/from_broadcasted_transactions.rs @@ -40,6 +40,7 @@ use starknet_core::types::{ use starknet_crypto::FieldElement; use thiserror::Error; +use super::BroadcastedDeclareTransactionV0; use crate::compute_hash::ComputeTransactionHash; #[derive(Debug, Error)] @@ -85,59 +86,93 @@ pub fn try_account_tx_from_broadcasted_tx( } } +fn try_new_declare_transaction( + tx: starknet_api::transaction::DeclareTransaction, + tx_hash: TransactionHash, + class_info: ClassInfo, + is_query: bool, +) -> Result { + if is_query { + DeclareTransaction::new_for_query(tx, tx_hash, class_info) + } else { + DeclareTransaction::new(tx, tx_hash, class_info) + } + .map_err(|_| BroadcastedTransactionConversionError::InvalidTransactionVersion) +} + +fn decompress_and_extract_data( + compressed_contract_class: &CompressedLegacyContractClass, +) -> Result<(Vec, FieldElement, usize), BroadcastedTransactionConversionError> { + // Create a GzipDecoder to decompress the bytes + let mut gz = GzDecoder::new(&compressed_contract_class.program[..]); + + // Read the decompressed bytes into a Vec + let mut decompressed_bytes = Vec::new(); + std::io::Read::read_to_end(&mut gz, &mut decompressed_bytes) + .map_err(|_| BroadcastedTransactionConversionError::ProgramDecompressionFailed)?; + + let class_hash = { + let legacy_contract_class = LegacyContractClass { + program: serde_json::from_slice(decompressed_bytes.as_slice()) + .map_err(|_| BroadcastedTransactionConversionError::ProgramDeserializationFailed)?, + abi: match compressed_contract_class.abi.as_ref() { + Some(abi) => abi.iter().cloned().map(|entry| entry.into()).collect::>(), + None => vec![], + }, + entry_points_by_type: to_raw_legacy_entry_points(compressed_contract_class.entry_points_by_type.clone()), + }; + + legacy_contract_class + .class_hash() + .map_err(|_| BroadcastedTransactionConversionError::ClassHashComputationFailed)? + }; + let abi_length = compressed_contract_class.abi.as_ref().map(|abi| abi.len()).unwrap_or_default(); + + Ok((decompressed_bytes, class_hash, abi_length)) +} + +pub fn try_declare_tx_from_broadcasted_declare_tx_v0( + value: BroadcastedDeclareTransactionV0, + chain_id: Felt252Wrapper, +) -> Result { + let BroadcastedDeclareTransactionV0 { + sender_address, + max_fee, + signature, + contract_class: compressed_contract_class, + is_query, + } = value; + + let (decompressed_bytes, class_hash, abi_length) = decompress_and_extract_data(compressed_contract_class.as_ref())?; + let tx = starknet_api::transaction::DeclareTransaction::V0(starknet_api::transaction::DeclareTransactionV0V1 { + max_fee: Fee(max_fee.try_into().map_err(|_| BroadcastedTransactionConversionError::MaxFeeTooBig)?), + signature: TransactionSignature(signature.into_iter().map(|v| Felt252Wrapper::from(v).into()).collect()), + nonce: Default::default(), + class_hash: Felt252Wrapper::from(class_hash).into(), + sender_address: Felt252Wrapper::from(sender_address).into(), + }); + + let contract_class = instantiate_blockifier_contract_class(compressed_contract_class, decompressed_bytes)?; + let tx_hash = tx.compute_hash(chain_id, is_query); + + try_new_declare_transaction(tx, tx_hash, ClassInfo::new(&contract_class, 0, abi_length)?, is_query) +} + pub fn try_declare_tx_from_broadcasted_declare_tx( value: BroadcastedDeclareTransaction, chain_id: Felt252Wrapper, ) -> Result { - fn try_new_declare_transaction( - tx: starknet_api::transaction::DeclareTransaction, - tx_hash: TransactionHash, - class_info: ClassInfo, - is_query: bool, - ) -> Result { - if is_query { - DeclareTransaction::new_for_query(tx, tx_hash, class_info) - } else { - DeclareTransaction::new(tx, tx_hash, class_info) - } - .map_err(|_| BroadcastedTransactionConversionError::InvalidTransactionVersion) - } - let user_tx = match value { BroadcastedDeclareTransaction::V1(BroadcastedDeclareTransactionV1 { max_fee, signature, nonce, - contract_class: compresed_contract_class, + contract_class: compressed_contract_class, sender_address, is_query, }) => { - // Create a GzipDecoder to decompress the bytes - let mut gz = GzDecoder::new(&compresed_contract_class.program[..]); - - // Read the decompressed bytes into a Vec - let mut decompressed_bytes = Vec::new(); - std::io::Read::read_to_end(&mut gz, &mut decompressed_bytes) - .map_err(|_| BroadcastedTransactionConversionError::ProgramDecompressionFailed)?; - - let class_hash = { - let legacy_contract_class = LegacyContractClass { - program: serde_json::from_slice(decompressed_bytes.as_slice()) - .map_err(|_| BroadcastedTransactionConversionError::ProgramDeserializationFailed)?, - abi: match compresed_contract_class.abi.as_ref() { - Some(abi) => abi.iter().cloned().map(|entry| entry.into()).collect::>(), - None => vec![], - }, - entry_points_by_type: to_raw_legacy_entry_points( - compresed_contract_class.entry_points_by_type.clone(), - ), - }; - - legacy_contract_class - .class_hash() - .map_err(|_| BroadcastedTransactionConversionError::ClassHashComputationFailed)? - }; - let abi_length = compresed_contract_class.abi.as_ref().map(|abi| abi.len()).unwrap_or_default(); + let (decompressed_bytes, class_hash, abi_length) = + decompress_and_extract_data(compressed_contract_class.as_ref())?; let tx = starknet_api::transaction::DeclareTransaction::V1(starknet_api::transaction::DeclareTransactionV0V1 { max_fee: Fee(max_fee @@ -151,7 +186,7 @@ pub fn try_declare_tx_from_broadcasted_declare_tx( sender_address: Felt252Wrapper::from(sender_address).into(), }); - let contract_class = instantiate_blockifier_contract_class(compresed_contract_class, decompressed_bytes)?; + let contract_class = instantiate_blockifier_contract_class(compressed_contract_class, decompressed_bytes)?; let tx_hash = tx.compute_hash(chain_id, is_query); try_new_declare_transaction(tx, tx_hash, ClassInfo::new(&contract_class, 0, abi_length)?, is_query)? diff --git a/crates/primitives/transactions/src/lib.rs b/crates/primitives/transactions/src/lib.rs index 28f9b5f60e..11a9da2c88 100644 --- a/crates/primitives/transactions/src/lib.rs +++ b/crates/primitives/transactions/src/lib.rs @@ -9,13 +9,15 @@ pub mod from_broadcasted_transactions; #[cfg(feature = "client")] pub mod to_starknet_core_transaction; +use std::sync::Arc; + use blockifier::transaction::account_transaction::AccountTransaction; use blockifier::transaction::transaction_execution::Transaction; use sp_core::H256; use starknet_api::core::{ContractAddress, Nonce, PatriciaKey}; use starknet_api::hash::StarkFelt; use starknet_api::transaction::TransactionHash; -use starknet_core::types::{TransactionExecutionStatus, TransactionFinalityStatus}; +use starknet_core::types::{CompressedLegacyContractClass, TransactionExecutionStatus, TransactionFinalityStatus}; use starknet_ff::FieldElement; const SIMULATE_TX_VERSION_OFFSET: FieldElement = @@ -139,3 +141,19 @@ impl From<&Transaction> for TxType { } } } + +/// Broadcasted declare contract transaction v0. +#[derive(Debug, Eq, PartialEq)] +#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))] +pub struct BroadcastedDeclareTransactionV0 { + /// The address of the account contract sending the declaration transaction + pub sender_address: FieldElement, + /// The maximal fee that can be charged for including the transaction + pub max_fee: FieldElement, + /// Signature + pub signature: Vec, + /// The class to be declared + pub contract_class: Arc, + /// If set to `true`, uses a query-only transaction version that's invalid for execution + pub is_query: bool, +} diff --git a/starknet-rpc-test/Cargo.toml b/starknet-rpc-test/Cargo.toml index 492e33a0b3..a938ad5783 100644 --- a/starknet-rpc-test/Cargo.toml +++ b/starknet-rpc-test/Cargo.toml @@ -12,7 +12,8 @@ async-lock = "3.1.0" async-trait = { workspace = true } env_logger = "0.9" flate2 = { workspace = true } -reqwest = "0.11.18" +mp-transactions = { workspace = true, features = ["serde"] } +reqwest = { version = "0.11.22", features = ["json"] } rstest = "0.18.1" serde = "1.0.192" serde_json = "1.0.108" @@ -134,3 +135,7 @@ path = "trace_block.rs" [[test]] name = "starknet_trace_transaction" path = "trace_transaction.rs" + +[[test]] +name = "madara_add_declare_transaction_v0" +path = "declareV0.rs" diff --git a/starknet-rpc-test/contracts/proxy.json b/starknet-rpc-test/contracts/proxy.json new file mode 100644 index 0000000000..c001b80255 --- /dev/null +++ b/starknet-rpc-test/contracts/proxy.json @@ -0,0 +1,60109 @@ +{ + "abi": [ + { + "inputs": [], + "name": "finalized", + "outputs": [ + { + "name": "res", + "type": "felt" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "data": [ + { + "name": "new_governor_nominee", + "type": "felt" + }, + { + "name": "nominated_by", + "type": "felt" + } + ], + "keys": [], + "name": "governor_nominated", + "type": "event" + }, + { + "data": [ + { + "name": "cancelled_nominee", + "type": "felt" + }, + { + "name": "cancelled_by", + "type": "felt" + } + ], + "keys": [], + "name": "nomination_cancelled", + "type": "event" + }, + { + "data": [ + { + "name": "removed_governor", + "type": "felt" + }, + { + "name": "removed_by", + "type": "felt" + } + ], + "keys": [], + "name": "governor_removed", + "type": "event" + }, + { + "data": [ + { + "name": "new_governor", + "type": "felt" + } + ], + "keys": [], + "name": "governance_accepted", + "type": "event" + }, + { + "inputs": [ + { + "name": "account", + "type": "felt" + } + ], + "name": "is_governor", + "outputs": [ + { + "name": "is_governor_", + "type": "felt" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "init_governance", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "nominee", + "type": "felt" + } + ], + "name": "nominate_new_governor", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "cancelee", + "type": "felt" + } + ], + "name": "cancel_nomination", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "removee", + "type": "felt" + } + ], + "name": "remove_governor", + "outputs": [], + "type": "function" + }, + { + "inputs": [], + "name": "accept_governance", + "outputs": [], + "type": "function" + }, + { + "data": [ + { + "name": "implementation_hash", + "type": "felt" + }, + { + "name": "eic_hash", + "type": "felt" + }, + { + "name": "init_vector_len", + "type": "felt" + }, + { + "name": "init_vector", + "type": "felt*" + }, + { + "name": "final", + "type": "felt" + } + ], + "keys": [], + "name": "implementation_added", + "type": "event" + }, + { + "data": [ + { + "name": "implementation_hash", + "type": "felt" + }, + { + "name": "eic_hash", + "type": "felt" + }, + { + "name": "init_vector_len", + "type": "felt" + }, + { + "name": "init_vector", + "type": "felt*" + }, + { + "name": "final", + "type": "felt" + } + ], + "keys": [], + "name": "implementation_removed", + "type": "event" + }, + { + "data": [ + { + "name": "implementation_hash", + "type": "felt" + }, + { + "name": "eic_hash", + "type": "felt" + }, + { + "name": "init_vector_len", + "type": "felt" + }, + { + "name": "init_vector", + "type": "felt*" + } + ], + "keys": [], + "name": "implementation_upgraded", + "type": "event" + }, + { + "data": [ + { + "name": "implementation_hash", + "type": "felt" + } + ], + "keys": [], + "name": "implementation_finalized", + "type": "event" + }, + { + "inputs": [], + "name": "implementation", + "outputs": [ + { + "name": "implementation_hash_", + "type": "felt" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "name": "implementation_hash_", + "type": "felt" + }, + { + "name": "eic_hash", + "type": "felt" + }, + { + "name": "init_vector_len", + "type": "felt" + }, + { + "name": "init_vector", + "type": "felt*" + }, + { + "name": "final", + "type": "felt" + } + ], + "name": "implementation_time", + "outputs": [ + { + "name": "time", + "type": "felt" + } + ], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { + "name": "implementation_hash_", + "type": "felt" + }, + { + "name": "eic_hash", + "type": "felt" + }, + { + "name": "init_vector_len", + "type": "felt" + }, + { + "name": "init_vector", + "type": "felt*" + }, + { + "name": "final", + "type": "felt" + } + ], + "name": "add_implementation", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "implementation_hash_", + "type": "felt" + }, + { + "name": "eic_hash", + "type": "felt" + }, + { + "name": "init_vector_len", + "type": "felt" + }, + { + "name": "init_vector", + "type": "felt*" + }, + { + "name": "final", + "type": "felt" + } + ], + "name": "remove_implementation", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "implementation_hash_", + "type": "felt" + }, + { + "name": "eic_hash", + "type": "felt" + }, + { + "name": "init_vector_len", + "type": "felt" + }, + { + "name": "init_vector", + "type": "felt*" + }, + { + "name": "final", + "type": "felt" + } + ], + "name": "upgrade_to", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "init_vector_len", + "type": "felt" + }, + { + "name": "init_vector", + "type": "felt*" + } + ], + "name": "initialize", + "outputs": [], + "type": "function" + }, + { + "inputs": [ + { + "name": "upgrade_delay_seconds", + "type": "felt" + } + ], + "name": "constructor", + "outputs": [], + "type": "constructor" + }, + { + "inputs": [ + { + "name": "selector", + "type": "felt" + }, + { + "name": "calldata_size", + "type": "felt" + }, + { + "name": "calldata", + "type": "felt*" + } + ], + "name": "__default__", + "outputs": [ + { + "name": "retdata_size", + "type": "felt" + }, + { + "name": "retdata", + "type": "felt*" + } + ], + "type": "function" + }, + { + "inputs": [ + { + "name": "selector", + "type": "felt" + }, + { + "name": "calldata_size", + "type": "felt" + }, + { + "name": "calldata", + "type": "felt*" + } + ], + "name": "__l1_default__", + "outputs": [], + "type": "l1_handler" + } + ], + "entry_points_by_type": { + "CONSTRUCTOR": [ + { + "offset": "0x669", + "selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194" + } + ], + "EXTERNAL": [ + { + "offset": "0x68d", + "selector": "0x0" + }, + { + "offset": "0x611", + "selector": "0x79dc0da7c54b95f10aa182ad0a46400db63156920adb65eca2654c0945a463" + }, + { + "offset": "0xcf", + "selector": "0xcfc0e4c73ce8e46b07c3167ce01ce17e6c2deaaa5b88b977bbb10abe25c9ad" + }, + { + "offset": "0x507", + "selector": "0xd43941048da98e5d91155f568f15da2ac665270f823156af4a151cc6f01869" + }, + { + "offset": "0x1d6", + "selector": "0xddbce093aac16b73fee61c0b88929c421b44a7b0f5eea63c3d5751c2ce7856" + }, + { + "offset": "0x2a7", + "selector": "0xe49d8b1fd8837abeba585912ed5e4baf9afab856352e8d561ec583ec3e07c9" + }, + { + "offset": "0x5e9", + "selector": "0xed163e8350935d550d16de1f53fd8284b06f37685f9d20c7f1735f719f336e" + }, + { + "offset": "0x20d", + "selector": "0x195d4289b867c3d98c335ea31402667f3592e227faf3d2991308563ed102aab" + }, + { + "offset": "0x23e", + "selector": "0x1e7a77b5074503274b30e0668ed3e3370061f6ca9a804a6ef595eca615ae2b9" + }, + { + "offset": "0x273", + "selector": "0x24ebb738b266180bbd9584b568849a498b630fc443a124b9a706df121f39c0d" + }, + { + "offset": "0x4b4", + "selector": "0x261e84c3bf0cd91f662ef6a323744d295f57c9f73e2a8f7cb7b2fc4bb732a41" + }, + { + "offset": "0x55a", + "selector": "0x338dd2002b6f7ac6471742691de72611381e3fc4ce2b0361c29d42cb2d53a90" + }, + { + "offset": "0x2da", + "selector": "0x39c93e2133cb77c722e54da8fab6e0231a5fe8341be262436094de7358e3477" + }, + { + "offset": "0x48d", + "selector": "0x3a0ed1f62da1d3048614c2c1feb566f041c8467eb00fb8294776a9179dc1643" + } + ], + "L1_HANDLER": [ + { + "offset": "0x6a6", + "selector": "0x0" + } + ] + }, + "program": { + "attributes": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized" + ], + "end_pc": 229, + "flow_tracking_data": { + "ap_tracking": { + "group": 23, + "offset": 28 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 227, + "value": "FINALIZED" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "end_pc": 495, + "flow_tracking_data": { + "ap_tracking": { + "group": 41, + "offset": 23 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 493, + "value": "ALREADY_INITIALIZED" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "end_pc": 500, + "flow_tracking_data": { + "ap_tracking": { + "group": 41, + "offset": 29 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 498, + "value": "ZERO_ADDRESS" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "end_pc": 550, + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 64 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 548, + "value": "ALREADY_GOVERNOR" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "end_pc": 553, + "flow_tracking_data": { + "ap_tracking": { + "group": 44, + "offset": 64 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 550, + "value": "ZERO_ADDRESS" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "end_pc": 655, + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 64 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 653, + "value": "NOT_A_GOVERNOR" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "end_pc": 661, + "flow_tracking_data": { + "ap_tracking": { + "group": 52, + "offset": 72 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 658, + "value": "CANNOT_SELF_REMOVE" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "end_pc": 708, + "flow_tracking_data": { + "ap_tracking": { + "group": 55, + "offset": 67 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 706, + "value": "NOT_A_GOVERNANCE_CANDIDATE" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "end_pc": 756, + "flow_tracking_data": { + "ap_tracking": { + "group": 57, + "offset": 73 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 754, + "value": "ONLY_GOVERNOR" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "end_pc": 1246, + "flow_tracking_data": { + "ap_tracking": { + "group": 93, + "offset": 88 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 1243, + "value": "NOT_AN_IMPLEMENTATION" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "end_pc": 1435, + "flow_tracking_data": { + "ap_tracking": { + "group": 104, + "offset": 61 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 1432, + "value": "UNKNOWN_IMPLEMENTATION" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "end_pc": 1453, + "flow_tracking_data": { + "ap_tracking": { + "group": 104, + "offset": 92 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 1448, + "value": "NOT_ENABLED_YET" + }, + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize" + ], + "end_pc": 1549, + "flow_tracking_data": { + "ap_tracking": { + "group": 113, + "offset": 0 + }, + "reference_ids": {} + }, + "name": "error_message", + "start_pc": 1545, + "value": "DIRECT_CALL_PROHIBITED" + } + ], + "builtins": ["pedersen", "range_check"], + "data": [ + "0x40780017fff7fff", + "0x1", + "0x208b7fff7fff7ffe", + "0x400380007ffb7ffc", + "0x400380017ffb7ffd", + "0x482680017ffb8000", + "0x3", + "0x480280027ffb8000", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x3", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480080007fff8000", + "0x400080007ffd7fff", + "0x482480017ffd8001", + "0x1", + "0x482480017ffd8001", + "0x1", + "0xa0680017fff7ffe", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffb", + "0x402a7ffc7ffd7fff", + "0x208b7fff7fff7ffe", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffd", + "0x4", + "0x400780017fff7ffd", + "0x1", + "0x208b7fff7fff7ffe", + "0x48297ffd80007ffc", + "0x20680017fff7fff", + "0x4", + "0x402780017ffc7ffc", + "0x1", + "0x208b7fff7fff7ffe", + "0x400380007ffc7ffd", + "0x482680017ffc8000", + "0x1", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x48297ffc80007ffd", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffb", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x3ffffffffffffffffffffffffffffff", + "0x480280017ffc8000", + "0x48307fff80007ffe", + "0x400280027ffc7fff", + "0x480280017ffc8000", + "0x484480017fff8000", + "0x100000000000000000000000000000000", + "0x480280007ffc8000", + "0x40317fff7ffe7ffd", + "0x482680017ffc8000", + "0x3", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x20680017fff7fff", + "0x10", + "0x480a7ffc7fff8000", + "0x482680017ffd8000", + "0x11000000000000000000000000000000000000000000000101", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffed", + "0x480680017fff8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x48127ffe7fff8000", + "0x48287ffd80007ffe", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe7", + "0x482680017ffd8000", + "0x11000000000000000000000000000000000000000000000101", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x20680017fff7fff", + "0xc", + "0x40780017fff7fff", + "0xa", + "0x480680017fff8000", + "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeff", + "0x480a7ffc7fff8000", + "0x48287ffd80007ffe", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd8", + "0x10780017fff7fff", + "0x8", + "0x40780017fff7fff", + "0xb", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd0", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x4c69627261727943616c6c", + "0x400280007ff97fff", + "0x400380017ff97ffa", + "0x400380027ff97ffb", + "0x400380037ff97ffc", + "0x400380047ff97ffd", + "0x482680017ff98000", + "0x7", + "0x480280057ff98000", + "0x480280067ff98000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x4c69627261727943616c6c4c3148616e646c6572", + "0x400280007ff97fff", + "0x400380017ff97ffa", + "0x400380027ff97ffb", + "0x400380037ff97ffc", + "0x400380047ff97ffd", + "0x482680017ff98000", + "0x7", + "0x480280057ff98000", + "0x480280067ff98000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x47657443616c6c657241646472657373", + "0x400280007ffd7fff", + "0x482680017ffd8000", + "0x2", + "0x480280017ffd8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x476574426c6f636b54696d657374616d70", + "0x400280007ffd7fff", + "0x482680017ffd8000", + "0x2", + "0x480280017ffd8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x53746f7261676552656164", + "0x400280007ffc7fff", + "0x400380017ffc7ffd", + "0x482680017ffc8000", + "0x3", + "0x480280027ffc8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x53746f726167655772697465", + "0x400280007ffb7fff", + "0x400380017ffb7ffc", + "0x400380027ffb7ffd", + "0x482680017ffb8000", + "0x3", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x456d69744576656e74", + "0x400280007ff97fff", + "0x400380017ff97ffa", + "0x400380027ff97ffb", + "0x400380037ff97ffc", + "0x400380047ff97ffd", + "0x482680017ff98000", + "0x5", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x3deed800708b45e9b8d2fb1c674394761dfb20b8c89d199e6c4cdb0974dd906", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffa", + "0x480a7ffb7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffdc", + "0x48127ffe7fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffed", + "0x480a7ffa7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd6", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe5", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x4003800080007ffc", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x4828800080007ffe", + "0x480a80007fff8000", + "0x208b7fff7fff7ffe", + "0x402b7ffd7ffc7ffd", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffee", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff1", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe0", + "0x400680017fff7fff", + "0x0", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff3", + "0x480680017fff8000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffc5", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0xe8fc4f1b6b3dc661208f9a8a5017a6c059098327e31518722e0a5c3a5a7e86", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffa", + "0x480a7ffb7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff8b", + "0x48127ffe7fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffed", + "0x480a7ffa7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff85", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x10bce98963d2e4d3c96d1d25422c3d2a989cdbb9fb71db6f95dcbfba8c4b3c8", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffeef", + "0x480a7ffc7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff22", + "0x48127fe17fff8000", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff0", + "0x480a7ffa7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff63", + "0x48127ffe7fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe2", + "0x480a7ff97fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff5c", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x222d6589b56d0ac1912a58387989f966f458b8de84e71844d58a394dafbd671", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffec6", + "0x480a7ffc7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffef9", + "0x48127fe17fff8000", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff0", + "0x480a7ffa7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff3a", + "0x48127ffe7fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe2", + "0x480a7ff97fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff33", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe9c", + "0x40137fff7fff8000", + "0x480680017fff8000", + "0x3774b0545aabb37c45c1eddc6a7dae57de498aae6d5e3589e362d4b4323a533", + "0x4002800080007fff", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe96", + "0x40137fff7fff8001", + "0x4003800080017ffc", + "0x4003800180017ffd", + "0x4826800180018000", + "0x2", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480a80007fff8000", + "0x4828800180007ffc", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff21", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe83", + "0x40137fff7fff8000", + "0x480680017fff8000", + "0x19b0b96cb0e0029733092527bca81129db5f327c064199b31ed8a9f857fdee3", + "0x4002800080007fff", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe7d", + "0x40137fff7fff8001", + "0x4003800080017ffc", + "0x4003800180017ffd", + "0x4826800180018000", + "0x2", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480a80007fff8000", + "0x4828800180007ffc", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff08", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe6a", + "0x40137fff7fff8000", + "0x480680017fff8000", + "0x3b7aa6f257721ed65dae25f8a1ee350b92d02cd59a9dcfb1fc4e8887be194ec", + "0x4002800080007fff", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe64", + "0x40137fff7fff8001", + "0x4003800080017ffc", + "0x4003800180017ffd", + "0x4826800180018000", + "0x2", + "0x480a7ffa7fff8000", + "0x480680017fff8000", + "0x1", + "0x480a80007fff8000", + "0x4828800180007ffc", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffeef", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe51", + "0x40137fff7fff8000", + "0x480680017fff8000", + "0x4595132f9b33b7077ebf2e7f3eb746a8e0a6d5c337c71cd8f9bf46cac3cfd7", + "0x4002800080007fff", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe4b", + "0x40137fff7fff8001", + "0x4003800080017ffd", + "0x4826800180018000", + "0x1", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480a80007fff8000", + "0x4828800180007ffc", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffed7", + "0x480a7ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff56", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x4003800080007ffc", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x4828800080007ffe", + "0x480a80007fff8000", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffea", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffee", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff0e", + "0x400680017fff7fff", + "0x0", + "0x48127ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe8b", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe28", + "0x48127ffc7fff8000", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x480680017fff8000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff0d", + "0x48127fe77fff8000", + "0x480680017fff8000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff30", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x48127fac7fff8000", + "0x48127fab7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff60", + "0x48127f947fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffa8", + "0x48127ffe7fff8000", + "0x48127fcc7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x402b7ffd7ffc7ffd", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd8", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0xca", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffa5", + "0x400680017fff7fff", + "0x0", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffdf3", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff28", + "0x48127ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe49", + "0x48127ffe7fff8000", + "0x48127ff87fff8000", + "0x480a7ffd7fff8000", + "0x48127ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff2c", + "0x48127ffe7fff8000", + "0x48127fdd7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd8", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x96", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffef3", + "0x20680017fff7fff", + "0x6", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffef3", + "0x48127ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe14", + "0x48127ffe7fff8000", + "0x48127ff87fff8000", + "0x480a7ffd7fff8000", + "0x48127ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff10", + "0x48127ffe7fff8000", + "0x48127fdd7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd7", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x61", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff3c", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd8d", + "0x48127ffa7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffdeb", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd8c", + "0x48127ffa7fff8000", + "0x48127ff07fff8000", + "0x48127ff07fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x0", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe93", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x48127fbc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffef5", + "0x48127ffe7fff8000", + "0x48127fe37fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd8", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffdc1", + "0x48127ffe7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x48127ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe89", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd58", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127fbd7fff8000", + "0x480680017fff8000", + "0x0", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe8d", + "0x48127f847fff8000", + "0x480680017fff8000", + "0x1", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe5f", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x48127f497fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffedb", + "0x48127ffe7fff8000", + "0x48127fe47fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x402b7ffd7ffc7ffd", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffdc", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd91", + "0x48127ffe7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x48127ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffed7", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd28", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x48127ffa7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd1f", + "0x400780017fff8000", + "0x0", + "0x400780017fff8001", + "0x0", + "0x48127ffe7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x480a7ffa7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480280007ffb8000", + "0x1104800180018000", + "0x20", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd0f", + "0x40137ffd7fff8000", + "0x480280017ffb8000", + "0x40297ffd7fff8001", + "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x480a7ffb7fff8000", + "0x480280007ffc8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffced", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd00", + "0x40137ffd7fff8000", + "0x480280017ffc8000", + "0x402580017fff8001", + "0x1", + "0x48127ffb7fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcdf", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffc", + "0x5", + "0x480a7ffa7fff8000", + "0x480a7ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x482680017ffc8000", + "0x800000000000011000000000000000000000000000000000000000000000000", + "0x40337fff7ffb8000", + "0x480a7ffb7fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffd7fff8000", + "0x48317ffd80008000", + "0x400080007ffd7ffe", + "0x480080007ffc8000", + "0x400080017ffc7fff", + "0x482480017ffb8000", + "0x1", + "0x482480017ffb8000", + "0x3", + "0x480080027ffa8000", + "0x20680017fff7ffb", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff8", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcbe", + "0x40137fff7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x3c0ba99f1a18bcdc81fcbcb6b4f15a9a6725f937075aed6fac107ffcb147068", + "0x4829800080008000", + "0x480a80007fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd17", + "0x482480017fff8000", + "0x1", + "0x40307ffe7ffd7fff", + "0x48127ffc7fff8000", + "0x480a7ffc7fff8000", + "0x480080007ffc8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcaa", + "0x40137fff7fff8000", + "0x4003800080007ffc", + "0x400380007ffa7ffc", + "0x402780017ffa8001", + "0x1", + "0x4826800180008000", + "0x1", + "0x40297ffc7fff8002", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffca5", + "0x480a7ff97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x79dc0da7c54b95f10aa182ad0a46400db63156920adb65eca2654c0945a463", + "0x4829800080008002", + "0x480a80007fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcf6", + "0x48127ffd7fff8000", + "0x480a80017fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc8d", + "0x40137fff7fff8000", + "0x4003800080007ffc", + "0x400380007ffa7ffc", + "0x402780017ffa8001", + "0x1", + "0x4826800180008000", + "0x1", + "0x40297ffc7fff8002", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc88", + "0x480a7ff97fff8000", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x3ea3b9a8522d36784cb325f9c7e2ec3c9f3e6d63031a6c6b8743cc22412f604", + "0x4829800080008002", + "0x480a80007fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcd9", + "0x48127ffd7fff8000", + "0x480a80017fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x3fc801c47df4de8d5835f8bfd4d0b8823ba63e5a3f278086901402d680abfc", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffa", + "0x480a7ffb7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcef", + "0x48127ffe7fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffed", + "0x480a7ffa7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffce9", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1ac8d354f2e793629cb233a16f10d13cf15b9c45bbc620577c8e1df95ede545", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc53", + "0x480a7ffc7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc86", + "0x48127fe17fff8000", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff0", + "0x480a7ffa7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcc7", + "0x48127ffe7fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe2", + "0x480a7ff97fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcc0", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x480680017fff8000", + "0x1c76cd4f3f79786d9e5d1298f47170de4bf0222337c680c5377ec772d3ce96b", + "0x208b7fff7fff7ffe", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffffa", + "0x480a7ffb7fff8000", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffca8", + "0x48127ffe7fff8000", + "0x48127ff57fff8000", + "0x48127ff57fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffed", + "0x480a7ffa7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffca2", + "0x48127ff67fff8000", + "0x48127ff67fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x4", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc0b", + "0x40137fff7fff8000", + "0x480680017fff8000", + "0x2e8a4ec40a36a027111fafdb6a46746ff1b0125d5067fbaebd8b5f227185a1e", + "0x4002800080007fff", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc05", + "0x40137fff7fff8001", + "0x4003800080017ff9", + "0x4003800180017ffa", + "0x4003800280017ffb", + "0x400380007ff87ffb", + "0x402780017ff88002", + "0x1", + "0x4826800180018000", + "0x3", + "0x40297ffb7fff8003", + "0x4826800180018000", + "0x3", + "0x480a7ffc7fff8000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffbfe", + "0x4003800080037ffd", + "0x4826800180038000", + "0x1", + "0x480a7ff77fff8000", + "0x480680017fff8000", + "0x1", + "0x480a80007fff8000", + "0x4828800180007ffc", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc82", + "0x480a80027fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x4", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffbe4", + "0x40137fff7fff8000", + "0x480680017fff8000", + "0x3ef46b1f8c5c94765c1d63fb24422442ea26f49289a18ba89c4138ebf450f6c", + "0x4002800080007fff", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffbde", + "0x40137fff7fff8001", + "0x4003800080017ff9", + "0x4003800180017ffa", + "0x4003800280017ffb", + "0x400380007ff87ffb", + "0x402780017ff88002", + "0x1", + "0x4826800180018000", + "0x3", + "0x40297ffb7fff8003", + "0x4826800180018000", + "0x3", + "0x480a7ffc7fff8000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffbd7", + "0x4003800080037ffd", + "0x4826800180038000", + "0x1", + "0x480a7ff77fff8000", + "0x480680017fff8000", + "0x1", + "0x480a80007fff8000", + "0x4828800180007ffc", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc5b", + "0x480a80027fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x4", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffbbd", + "0x40137fff7fff8000", + "0x480680017fff8000", + "0x1205ec81562fc65c367136bd2fe1c0fff2d1986f70e4ba365e5dd747bd08753", + "0x4002800080007fff", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffbb7", + "0x40137fff7fff8001", + "0x4003800080017ffa", + "0x4003800180017ffb", + "0x4003800280017ffc", + "0x400380007ff97ffc", + "0x402780017ff98002", + "0x1", + "0x4826800180018000", + "0x3", + "0x40297ffc7fff8003", + "0x4826800180018000", + "0x3", + "0x480a7ffd7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffbb0", + "0x480a7ff87fff8000", + "0x480680017fff8000", + "0x1", + "0x480a80007fff8000", + "0x4829800180008003", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc37", + "0x480a80027fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x2", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffb99", + "0x40137fff7fff8000", + "0x480680017fff8000", + "0x2c6e1be7705f64cd4ec61d51a0c8e64ceed5e787198bd3291469fb870578922", + "0x4002800080007fff", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffb93", + "0x40137fff7fff8001", + "0x4003800080017ffd", + "0x4826800180018000", + "0x1", + "0x480a7ffb7fff8000", + "0x480680017fff8000", + "0x1", + "0x480a80007fff8000", + "0x4828800180007ffc", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffc1f", + "0x480a7ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff5b", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x4003800080007ffc", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x4828800080007ffe", + "0x480a80007fff8000", + "0x208b7fff7fff7ffe", + "0x402b7ffd7ffc7ffd", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffee", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff1", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff77fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x1a7", + "0x480a7ff67fff8000", + "0x48127ffd7fff8000", + "0x480a7ff87fff8000", + "0x48127ffc7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff14", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x1", + "0x4003800080007ffc", + "0x4826800180008000", + "0x1", + "0x480a7ffd7fff8000", + "0x4828800080007ffe", + "0x480a80007fff8000", + "0x208b7fff7fff7ffe", + "0x480280027ffb8000", + "0x480280027ffd8000", + "0x400080007ffe7fff", + "0x482680017ffd8000", + "0x3", + "0x480280027ffd8000", + "0x48307fff7ffe8000", + "0x482480017fff8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280027ffb8000", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x482480017ffd8000", + "0x1", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x480280027ffd8000", + "0x482680017ffd8000", + "0x3", + "0x480080007ff68000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffd4", + "0x48127ffe7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe0", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x5", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe11", + "0x480a7ff97fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffb3e", + "0x48127ffa7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffba3", + "0x40137fff7fff8000", + "0x48127ffe7fff8000", + "0x48127ff47fff8000", + "0x48127ff47fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffeb0", + "0x40137fff7fff8001", + "0x40137ffc7fff8002", + "0x40137ffe7fff8003", + "0x48127ffd7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x159", + "0x480a80027fff8000", + "0x48127ffd7fff8000", + "0x480a80037fff8000", + "0x48127ffc7fff8000", + "0x482a800180008000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffed3", + "0x40137ffe7fff8004", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffef4", + "0x48127ffe7fff8000", + "0x480a80047fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x480280027ffb8000", + "0x480280027ffd8000", + "0x400080007ffe7fff", + "0x482680017ffd8000", + "0x3", + "0x480280027ffd8000", + "0x48307fff7ffe8000", + "0x482480017fff8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280027ffb8000", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x482480017ffd8000", + "0x1", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x480280027ffd8000", + "0x482680017ffd8000", + "0x3", + "0x480080007ff68000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffb9", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x3", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffdbe", + "0x40137ffd7fff8000", + "0x40137fff7fff8001", + "0x48127ffe7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x113", + "0x480a80007fff8000", + "0x48127ffd7fff8000", + "0x480a80017fff8000", + "0x48127ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe80", + "0x20680017fff7fff", + "0x6", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127fbf7fff8000", + "0x480680017fff8000", + "0x0", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe80", + "0x40137ffe7fff8002", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffec8", + "0x48127ffe7fff8000", + "0x480a80027fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x480280027ffb8000", + "0x480280027ffd8000", + "0x400080007ffe7fff", + "0x482680017ffd8000", + "0x3", + "0x480280027ffd8000", + "0x48307fff7ffe8000", + "0x482480017fff8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280027ffb8000", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x482480017ffd8000", + "0x1", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x480280027ffd8000", + "0x482680017ffd8000", + "0x3", + "0x480080007ff68000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffb9", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x9", + "0x480a7ff67fff8000", + "0x480a7ff77fff8000", + "0x480a7ff87fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd6b", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffb5e", + "0x40137fff7fff8000", + "0x48127ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffafd", + "0x40137fff7fff8001", + "0x40137ffe7fff8002", + "0x48127ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0xba", + "0x480a80027fff8000", + "0x48127ffd7fff8000", + "0x480a80007fff8000", + "0x48127ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe27", + "0x40137fff7fff8003", + "0x480a80037fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa81", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x48127ff97fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffee1", + "0x40137fff7fff8004", + "0x40137ffc7fff8005", + "0x40137ffd7fff8006", + "0x20780017fff8004", + "0x5", + "0x48127ffe7fff8000", + "0x10780017fff7fff", + "0x7", + "0x48127ffe7fff8000", + "0x480a80037fff8000", + "0x480a80017fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffa7e", + "0x480a80057fff8000", + "0x480a80067fff8000", + "0x48127ffd7fff8000", + "0x480a7ff97fff8000", + "0x1104800180018000", + "0x8f", + "0x40137ffe7fff8007", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe89", + "0x48127ffe7fff8000", + "0x480a80077fff8000", + "0x48127ffd7fff8000", + "0x480a7ffd7fff8000", + "0x480a7ff97fff8000", + "0x1104800180018000", + "0x6b", + "0x40137ffe7fff8008", + "0x20780017fff7ffa", + "0x4", + "0x10780017fff7fff", + "0xd", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffda6", + "0x48127ffe7fff8000", + "0x480a80087fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x480a7ff97fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd6c", + "0x20680017fff7fff", + "0xd", + "0x48127ffd7fff8000", + "0x48127ffd7fff8000", + "0x480a7ff97fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd77", + "0x48127ffe7fff8000", + "0x480a80087fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x48127ffd7fff8000", + "0x480a80087fff8000", + "0x48127ffc7fff8000", + "0x208b7fff7fff7ffe", + "0x480280027ffb8000", + "0x480280027ffd8000", + "0x400080007ffe7fff", + "0x482680017ffd8000", + "0x3", + "0x480280027ffd8000", + "0x48307fff7ffe8000", + "0x482480017fff8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280027ffb8000", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x482480017ffd8000", + "0x1", + "0x480280007ffd8000", + "0x480280017ffd8000", + "0x480280027ffd8000", + "0x482680017ffd8000", + "0x3", + "0x480080007ff68000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffff7d", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480680017fff8000", + "0x1", + "0x400680017fff7fff", + "0x0", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x400080007ffe7fff", + "0x482680017ffd8000", + "0x1", + "0x480280007ffd8000", + "0x48307fff7ffe8000", + "0x402a7ffd7ffc7fff", + "0x480280027ffb8000", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x482480017ffd8000", + "0x1", + "0x480280007ffd8000", + "0x482680017ffd8000", + "0x1", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe9", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x20780017fff7ffc", + "0x6", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffab5", + "0x48127ffd7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe2d", + "0x48127ffe7fff8000", + "0x48127fe47fff8000", + "0x48127ffd7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffca7", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffda3", + "0x208b7fff7fff7ffe", + "0x40780017fff7fff", + "0x0", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcae", + "0x480a7ff87fff8000", + "0x48127ffe7fff8000", + "0x480a7ff97fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcc3", + "0x480a7ffa7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcc0", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcbd", + "0x480a7ffc7fff8000", + "0x480a7ffb7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffca9", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcb6", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffcc4", + "0x208b7fff7fff7ffe", + "0x480a7ffa7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffd3c", + "0x208b7fff7fff7ffe", + "0x482680017ffd8000", + "0x1", + "0x402a7ffd7ffc7fff", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480280007ffd8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffff3", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffe01", + "0x48127ffc7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9de", + "0x48127ffd7fff8000", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x48127ffb7fff8000", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480a7ffa7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffe9", + "0x208b7fff7fff7ffe", + "0x480a7ff87fff8000", + "0x480a7ff97fff8000", + "0x480a7ffa7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffffde6", + "0x48127ffc7fff8000", + "0x48127ffe7fff8000", + "0x480a7ffb7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010fffffffffffffffffffffffffffffffffffffffffffff9cf", + "0x48127ffd7fff8000", + "0x48127ff17fff8000", + "0x48127ff17fff8000", + "0x208b7fff7fff7ffe", + "0x480280007ffb8000", + "0x480280017ffb8000", + "0x480280027ffb8000", + "0x480a7ffa7fff8000", + "0x480a7ffc7fff8000", + "0x480a7ffd7fff8000", + "0x1104800180018000", + "0x800000000000010ffffffffffffffffffffffffffffffffffffffffffffffeb", + "0x40780017fff7fff", + "0x1", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x48127ffc7fff8000", + "0x480680017fff8000", + "0x0", + "0x48127ffb7fff8000", + "0x208b7fff7fff7ffe" + ], + "debug_info": { + "file_contents": { + "autogen/starknet/arg_processor/17d835e5cff16987ba8eac1ec2a57cba4582fa1aaa6b2abcd6da5afc89692c9e.cairo": "assert [__calldata_ptr] = cancelled_nominee\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo": "assert [cast(fp + (-4), felt*)] = __calldata_actual_size\n", + "autogen/starknet/arg_processor/24c97f670ce31f815c23d458c5a6051e4b7ba12ac09ee0df538993191f984906.cairo": "assert [__calldata_ptr] = cancelled_by\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/2e595849d73b71aa109f5f1d3c29c013eb1dd58b510c79ea714007d20cece32a.cairo": "assert [__calldata_ptr] = removed_governor\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/363b233a7c697e07ee6a6af6c2ddef3c46ae0133d641833917804d0ad89c4a8d.cairo": "assert [__calldata_ptr] = new_governor\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo": "assert [__calldata_ptr] = init_vector_len\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/492648d59c697ae70640b4e48da59ebd65103052828f6145a8284bc82314cf20.cairo": "assert [__calldata_ptr] = new_governor_nominee\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/5e1cc73f0b484f90bb02da164d88332b40c6f698801aa4d3c603dab22157e902.cairo": "let __calldata_actual_size = __calldata_ptr - cast([cast(fp + (-3), felt**)], felt*)\n", + "autogen/starknet/arg_processor/66ce5052d98668fd8687fa8fb10ac402eee7cf7e1ac14c755b464fade89c3881.cairo": "assert [__calldata_ptr] = implementation_hash\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/6a9e5474458c08b7b096934bef7fcca112846641f1e280aadf6f50bafc4a5bc0.cairo": "assert [__calldata_ptr] = removed_by\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo": "let __calldata_arg_init_vector_len = [__calldata_ptr]\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/7174b24f581d23f70bd4d8ce2ea0c2b36ec7a7f140792036ec3116d51ba04a0c.cairo": "assert [__calldata_ptr] = final\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/76d47b6ecb46e7f4250b26887706f0f04aa2361d0143dad18e4d95f1bc581c2f.cairo": "let __return_value_arg_res = [__return_value_ptr]\nlet __return_value_ptr = __return_value_ptr + 1\n", + "autogen/starknet/arg_processor/7e43e5183ee46e00aab342ce0cb4c926a655274ff7f4f0d65a657711fbffdc3d.cairo": "let __calldata_arg_final = [__calldata_ptr]\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/86dea33f8d6357e54eedfd8e6e4056320a7cdfd419ce0c0410a0b9a23a277d25.cairo": "assert [__return_value_ptr] = ret_value.time\nlet __return_value_ptr = __return_value_ptr + 1\n", + "autogen/starknet/arg_processor/8b6bed184f49fa9e870af4864a777f1106d12a9d69a2437bcd6416567487bf13.cairo": "let __calldata_arg_cancelee = [__calldata_ptr]\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/928e8ea0335478f7ee270fc274a2081a0cb7a059bbc6b82d44867e997798c8fb.cairo": "assert [__calldata_ptr] = eic_hash\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/a14f7b648fb3ba6431b9ea0aec1e8e663818e10f9e10eb57b1c38ab239df4db0.cairo": "assert [__return_value_ptr] = ret_value.is_governor_\nlet __return_value_ptr = __return_value_ptr + 1\n", + "autogen/starknet/arg_processor/a1a0b1df7500c649c93378b5d1c29f9be2447318df4cbac9173096fb323783fd.cairo": "let __calldata_arg_upgrade_delay_seconds = [__calldata_ptr]\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/a46542dc358872d57a2d9f424e61d9b07a0e4c72f24e3645022494cebfb47c83.cairo": "assert [__return_value_ptr] = ret_value.res\nlet __return_value_ptr = __return_value_ptr + 1\n", + "autogen/starknet/arg_processor/a728d24eb4669a8e6860e6c0a3b4f06e3de9bab90a8ca676c0bcf3c287ac921b.cairo": "let __calldata_arg_account = [__calldata_ptr]\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/b0dcc1491822147bd0ab1828bd650b5232e20e602d6427c1cb6b4ec241a9cdb5.cairo": "assert retdata_size = __return_value_actual_size\n", + "autogen/starknet/arg_processor/b3dc4f7080ff6316032cfe42a522b2a826c5eaa7df04ae64b32d9b11aeedfda0.cairo": "let __calldata_arg_nominee = [__calldata_ptr]\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/b81f27b64c06a9309a49596002ea7e11631cc26feee830846c7da27aeff0e17a.cairo": "assert [__calldata_ptr] = nominated_by\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo": "# Check that the length is non-negative.\nassert [range_check_ptr] = __calldata_arg_init_vector_len\nlet range_check_ptr = range_check_ptr + 1\n# Create the reference.\nlet __calldata_arg_init_vector = cast(__calldata_ptr, felt*)\n# Use 'tempvar' instead of 'let' to avoid repeating this computation for the\n# following arguments.\ntempvar __calldata_ptr = __calldata_ptr + __calldata_arg_init_vector_len * 1\n", + "autogen/starknet/arg_processor/d2ee302a18234bed9fbd456e6c41abd6fb5413110dcab9643a9c66e4b29a240a.cairo": "let __calldata_arg_implementation_hash_ = [__calldata_ptr]\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/d59c7dc669755d681093c87b3bcf4ac40da1fc4527d813dea68f0ecbc81f1e73.cairo": "assert [__return_value_ptr] = ret_value.implementation_hash_\nlet __return_value_ptr = __return_value_ptr + 1\n", + "autogen/starknet/arg_processor/eea8394a33414521e4ece8855a00f085f6843a8b97cef2bfb099279dfce7f148.cairo": "let __calldata_arg_eic_hash = [__calldata_ptr]\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/f3ca6393e0af20d9fe61c47a8d578ee2acd5b76d851afe770ee26235f964e8a6.cairo": "let __return_value_actual_size = __return_value_ptr - cast(retdata, felt*)\n", + "autogen/starknet/arg_processor/f47d2abc24b9c0ac5ed9d831b1926df2a946b6013fa5b67916fb38de8c86d431.cairo": "let __calldata_arg_removee = [__calldata_ptr]\nlet __calldata_ptr = __calldata_ptr + 1\n", + "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo": "# Check that the length is non-negative.\nassert [range_check_ptr] = init_vector_len\n# Store the updated range_check_ptr as a local variable to keep it available after\n# the memcpy.\nlocal range_check_ptr = range_check_ptr + 1\n# Keep a reference to __calldata_ptr.\nlet __calldata_ptr_copy = __calldata_ptr\n# Store the updated __calldata_ptr as a local variable to keep it available after\n# the memcpy.\nlocal __calldata_ptr : felt* = __calldata_ptr + init_vector_len * 1\nmemcpy(\n dst=__calldata_ptr_copy,\n src=init_vector,\n len=init_vector_len * 1)\n", + "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1b43ef6b4af8e72427aa5dbe8c8bae252da7027ca95f7e3d957ba8a9c97db773.cairo": "func library_call_eic_initialize{syscall_ptr : felt*, range_check_ptr}(\n class_hash : felt):\nend\n", + "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1ea6a15d153eb82ed57fee60e4a7212a1ca02205c458f23f0d80d5a00c7427e3.cairo": "\nlet (retdata_size, retdata) = library_call(\n class_hash=class_hash,\n function_selector=EIC_INITIALIZE_SELECTOR,\n calldata_size=__calldata_ptr - calldata_ptr_start,\n calldata=calldata_ptr_start)\n", + "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo": "\nalloc_locals\nlet (local calldata_ptr_start : felt*) = alloc()\nlet __calldata_ptr = calldata_ptr_start\n", + "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/f50361dd9bfac65181c540d35f212e1c4d9a5552b713bad47868a2b80022ed2a.cairo": "\nreturn ()\n", + "autogen/starknet/contract_interface/Initializable/initialize/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo": "\nalloc_locals\nlet (local calldata_ptr_start : felt*) = alloc()\nlet __calldata_ptr = calldata_ptr_start\n", + "autogen/starknet/contract_interface/Initializable/initialize/8c886c1d349f82bd591f8eec585855ee3491fc3ebec5aa6c756bbdba7906357e.cairo": "\nlet (retdata_size, retdata) = library_call(\n class_hash=class_hash,\n function_selector=INITIALIZE_SELECTOR,\n calldata_size=__calldata_ptr - calldata_ptr_start,\n calldata=calldata_ptr_start)\n", + "autogen/starknet/contract_interface/Initializable/initialize/9d9536b18a319f36eeef57c36e532f983f44265fc7e39581e2aa4bf1393efc61.cairo": "func library_call_initialize{syscall_ptr : felt*, range_check_ptr}(\n class_hash : felt):\nend\n", + "autogen/starknet/contract_interface/Initializable/initialize/f50361dd9bfac65181c540d35f212e1c4d9a5552b713bad47868a2b80022ed2a.cairo": "\nreturn ()\n", + "autogen/starknet/contract_interface/Initializable/initialized/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo": "\nalloc_locals\nlet (local calldata_ptr_start : felt*) = alloc()\nlet __calldata_ptr = calldata_ptr_start\n", + "autogen/starknet/contract_interface/Initializable/initialized/5c2b7aeab167481680df60350af517363d2959feb2d8d22d44792fc66abecaed.cairo": "\nlet (retdata_size, retdata) = library_call(\n class_hash=class_hash,\n function_selector=INITIALIZED_SELECTOR,\n calldata_size=__calldata_ptr - calldata_ptr_start,\n calldata=calldata_ptr_start)\n", + "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo": "func library_call_initialized{syscall_ptr : felt*, range_check_ptr}(\n class_hash : felt):\nend\n", + "autogen/starknet/contract_interface/Initializable/initialized/9a82246979d7b39f8f6ee8d4abee119d90648cb59b4c077f4d91669844f6695c.cairo": "\nreturn (res=__return_value_arg_res,)\n", + "autogen/starknet/event/governance_accepted/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo": "func emit{syscall_ptr : felt*, range_check_ptr}():\nend\n", + "autogen/starknet/event/governance_accepted/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo": "alloc_locals\nlet (local __keys_ptr : felt*) = alloc()\nassert [__keys_ptr] = SELECTOR\nlet (local __data_ptr : felt*) = alloc()\nlet __calldata_ptr = __data_ptr\n", + "autogen/starknet/event/governance_accepted/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo": "emit_event(keys_len=1, keys=__keys_ptr, data_len=__calldata_ptr - __data_ptr, data=__data_ptr)\nreturn ()\n", + "autogen/starknet/event/governor_nominated/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo": "func emit{syscall_ptr : felt*, range_check_ptr}():\nend\n", + "autogen/starknet/event/governor_nominated/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo": "alloc_locals\nlet (local __keys_ptr : felt*) = alloc()\nassert [__keys_ptr] = SELECTOR\nlet (local __data_ptr : felt*) = alloc()\nlet __calldata_ptr = __data_ptr\n", + "autogen/starknet/event/governor_nominated/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo": "emit_event(keys_len=1, keys=__keys_ptr, data_len=__calldata_ptr - __data_ptr, data=__data_ptr)\nreturn ()\n", + "autogen/starknet/event/governor_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo": "func emit{syscall_ptr : felt*, range_check_ptr}():\nend\n", + "autogen/starknet/event/governor_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo": "alloc_locals\nlet (local __keys_ptr : felt*) = alloc()\nassert [__keys_ptr] = SELECTOR\nlet (local __data_ptr : felt*) = alloc()\nlet __calldata_ptr = __data_ptr\n", + "autogen/starknet/event/governor_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo": "emit_event(keys_len=1, keys=__keys_ptr, data_len=__calldata_ptr - __data_ptr, data=__data_ptr)\nreturn ()\n", + "autogen/starknet/event/implementation_added/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo": "func emit{syscall_ptr : felt*, range_check_ptr}():\nend\n", + "autogen/starknet/event/implementation_added/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo": "alloc_locals\nlet (local __keys_ptr : felt*) = alloc()\nassert [__keys_ptr] = SELECTOR\nlet (local __data_ptr : felt*) = alloc()\nlet __calldata_ptr = __data_ptr\n", + "autogen/starknet/event/implementation_added/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo": "emit_event(keys_len=1, keys=__keys_ptr, data_len=__calldata_ptr - __data_ptr, data=__data_ptr)\nreturn ()\n", + "autogen/starknet/event/implementation_finalized/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo": "func emit{syscall_ptr : felt*, range_check_ptr}():\nend\n", + "autogen/starknet/event/implementation_finalized/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo": "alloc_locals\nlet (local __keys_ptr : felt*) = alloc()\nassert [__keys_ptr] = SELECTOR\nlet (local __data_ptr : felt*) = alloc()\nlet __calldata_ptr = __data_ptr\n", + "autogen/starknet/event/implementation_finalized/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo": "emit_event(keys_len=1, keys=__keys_ptr, data_len=__calldata_ptr - __data_ptr, data=__data_ptr)\nreturn ()\n", + "autogen/starknet/event/implementation_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo": "func emit{syscall_ptr : felt*, range_check_ptr}():\nend\n", + "autogen/starknet/event/implementation_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo": "alloc_locals\nlet (local __keys_ptr : felt*) = alloc()\nassert [__keys_ptr] = SELECTOR\nlet (local __data_ptr : felt*) = alloc()\nlet __calldata_ptr = __data_ptr\n", + "autogen/starknet/event/implementation_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo": "emit_event(keys_len=1, keys=__keys_ptr, data_len=__calldata_ptr - __data_ptr, data=__data_ptr)\nreturn ()\n", + "autogen/starknet/event/implementation_upgraded/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo": "func emit{syscall_ptr : felt*, range_check_ptr}():\nend\n", + "autogen/starknet/event/implementation_upgraded/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo": "alloc_locals\nlet (local __keys_ptr : felt*) = alloc()\nassert [__keys_ptr] = SELECTOR\nlet (local __data_ptr : felt*) = alloc()\nlet __calldata_ptr = __data_ptr\n", + "autogen/starknet/event/implementation_upgraded/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo": "emit_event(keys_len=1, keys=__keys_ptr, data_len=__calldata_ptr - __data_ptr, data=__data_ptr)\nreturn ()\n", + "autogen/starknet/event/nomination_cancelled/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo": "func emit{syscall_ptr : felt*, range_check_ptr}():\nend\n", + "autogen/starknet/event/nomination_cancelled/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo": "alloc_locals\nlet (local __keys_ptr : felt*) = alloc()\nassert [__keys_ptr] = SELECTOR\nlet (local __data_ptr : felt*) = alloc()\nlet __calldata_ptr = __data_ptr\n", + "autogen/starknet/event/nomination_cancelled/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo": "emit_event(keys_len=1, keys=__keys_ptr, data_len=__calldata_ptr - __data_ptr, data=__data_ptr)\nreturn ()\n", + "autogen/starknet/external/__default__/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/__default__/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/__default__/594cfed774c45850575554a78093a7a27edf1e635eae6c967f967cde5f6d9051.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(selector=[cast(fp + (-6), felt*)], calldata_size=[cast(fp + (-4), felt*)], calldata=[cast(fp + (-3), felt**)],)\nlet retdata_size = ret_value.retdata_size\nlet retdata = ret_value.retdata\n", + "autogen/starknet/external/__default__/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/__default__/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/__l1_default__/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/__l1_default__/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/__l1_default__/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/__l1_default__/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(selector=[cast(fp + (-6), felt*)], calldata_size=[cast(fp + (-4), felt*)], calldata=[cast(fp + (-3), felt**)],)\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/accept_governance/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/accept_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/accept_governance/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/accept_governance/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}()\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/add_implementation/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(implementation_hash_=__calldata_arg_implementation_hash_, eic_hash=__calldata_arg_eic_hash, init_vector_len=__calldata_arg_init_vector_len, init_vector=__calldata_arg_init_vector, final=__calldata_arg_final,)\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/add_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/add_implementation/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/add_implementation/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/cancel_nomination/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/cancel_nomination/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(cancelee=__calldata_arg_cancelee,)\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/cancel_nomination/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/cancel_nomination/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(upgrade_delay_seconds=__calldata_arg_upgrade_delay_seconds,)\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/constructor/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/constructor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/constructor/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/constructor/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}()\nlet (range_check_ptr, retdata_size, retdata) = finalized_encode_return(ret_value, range_check_ptr)\n", + "autogen/starknet/external/finalized/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/finalized/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/finalized/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/finalized/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/implementation/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}()\nlet (range_check_ptr, retdata_size, retdata) = implementation_encode_return(ret_value, range_check_ptr)\n", + "autogen/starknet/external/implementation/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/implementation/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/implementation_time/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/implementation_time/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(implementation_hash_=__calldata_arg_implementation_hash_, eic_hash=__calldata_arg_eic_hash, init_vector_len=__calldata_arg_init_vector_len, init_vector=__calldata_arg_init_vector, final=__calldata_arg_final,)\nlet (range_check_ptr, retdata_size, retdata) = implementation_time_encode_return(ret_value, range_check_ptr)\n", + "autogen/starknet/external/implementation_time/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/implementation_time/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/init_governance/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/init_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/init_governance/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/init_governance/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}()\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/initialize/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/initialize/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/initialize/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(init_vector_len=__calldata_arg_init_vector_len, init_vector=__calldata_arg_init_vector,)\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/initialize/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/is_governor/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/is_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(account=__calldata_arg_account,)\nlet (range_check_ptr, retdata_size, retdata) = is_governor_encode_return(ret_value, range_check_ptr)\n", + "autogen/starknet/external/is_governor/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/is_governor/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/nominate_new_governor/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/nominate_new_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(nominee=__calldata_arg_nominee,)\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/nominate_new_governor/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/nominate_new_governor/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/remove_governor/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/remove_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(removee=__calldata_arg_removee,)\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/remove_governor/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/remove_governor/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/remove_implementation/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(implementation_hash_=__calldata_arg_implementation_hash_, eic_hash=__calldata_arg_eic_hash, init_vector_len=__calldata_arg_init_vector_len, init_vector=__calldata_arg_init_vector, final=__calldata_arg_final,)\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/remove_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/remove_implementation/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/remove_implementation/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/external/return/finalized/291398c85e3156ab9c7a7286de7b4369dea58653d1e9a6668df867ac82fc77cc.cairo": "func finalized_encode_return(ret_value : (res : felt), range_check_ptr) -> (\n range_check_ptr, data_len : felt, data : felt*):\n %{ memory[ap] = segments.add() %}\n alloc_locals\n local __return_value_ptr_start : felt*\n let __return_value_ptr = __return_value_ptr_start\n with range_check_ptr:\n end\n return (\n range_check_ptr=range_check_ptr,\n data_len=__return_value_ptr - __return_value_ptr_start,\n data=__return_value_ptr_start)\nend\n", + "autogen/starknet/external/return/implementation/76277dac574af7bf0c2e447a5ae96652d6a6e738957009ad46f922f0ef5d185a.cairo": "func implementation_encode_return(ret_value : (implementation_hash_ : felt), range_check_ptr) -> (\n range_check_ptr, data_len : felt, data : felt*):\n %{ memory[ap] = segments.add() %}\n alloc_locals\n local __return_value_ptr_start : felt*\n let __return_value_ptr = __return_value_ptr_start\n with range_check_ptr:\n end\n return (\n range_check_ptr=range_check_ptr,\n data_len=__return_value_ptr - __return_value_ptr_start,\n data=__return_value_ptr_start)\nend\n", + "autogen/starknet/external/return/implementation_time/58056490058fccf98a30c1e808265651b36def4ea1622f0fb9743e72cfaeb35e.cairo": "func implementation_time_encode_return(ret_value : (time : felt), range_check_ptr) -> (\n range_check_ptr, data_len : felt, data : felt*):\n %{ memory[ap] = segments.add() %}\n alloc_locals\n local __return_value_ptr_start : felt*\n let __return_value_ptr = __return_value_ptr_start\n with range_check_ptr:\n end\n return (\n range_check_ptr=range_check_ptr,\n data_len=__return_value_ptr - __return_value_ptr_start,\n data=__return_value_ptr_start)\nend\n", + "autogen/starknet/external/return/is_governor/3595b8bc72801c1e0c0f1a6192e851e961c01fb57f1e1948ae8557d66579a8a7.cairo": "func is_governor_encode_return(ret_value : (is_governor_ : felt), range_check_ptr) -> (\n range_check_ptr, data_len : felt, data : felt*):\n %{ memory[ap] = segments.add() %}\n alloc_locals\n local __return_value_ptr_start : felt*\n let __return_value_ptr = __return_value_ptr_start\n with range_check_ptr:\n end\n return (\n range_check_ptr=range_check_ptr,\n data_len=__return_value_ptr - __return_value_ptr_start,\n data=__return_value_ptr_start)\nend\n", + "autogen/starknet/external/upgrade_to/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo": "let pedersen_ptr = [cast([cast(fp + (-5), felt**)] + 1, starkware.cairo.common.cairo_builtins.HashBuiltin**)]\n", + "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo": "let ret_value = __wrapped_func{syscall_ptr=syscall_ptr, pedersen_ptr=pedersen_ptr, range_check_ptr=range_check_ptr}(implementation_hash_=__calldata_arg_implementation_hash_, eic_hash=__calldata_arg_eic_hash, init_vector_len=__calldata_arg_init_vector_len, init_vector=__calldata_arg_init_vector, final=__calldata_arg_final,)\n%{ memory[ap] = segments.add() %} # Allocate memory for return value.\ntempvar retdata : felt*\nlet retdata_size = 0\n", + "autogen/starknet/external/upgrade_to/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo": "return (syscall_ptr,pedersen_ptr,range_check_ptr,retdata_size,retdata)\n", + "autogen/starknet/external/upgrade_to/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo": "let syscall_ptr = [cast([cast(fp + (-5), felt**)] + 0, felt**)]\n", + "autogen/starknet/external/upgrade_to/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo": "let range_check_ptr = [cast([cast(fp + (-5), felt**)] + 2, felt*)]\n", + "autogen/starknet/storage_var/_finalized/decl.cairo": "namespace _finalized:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt):\n let res = 0\n call hash2\n call normalize_address\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt):\n let storage_addr = 0\n call addr\n call storage_read\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(value : felt):\n let storage_addr = 0\n call addr\n call storage_write\n end\nend", + "autogen/starknet/storage_var/_finalized/impl.cairo": "namespace _finalized:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt):\n let res = 1750817759628730138691164646727852846149105572394507245695566810799057787142\n return (res=res)\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt):\n let (storage_addr) = addr()\n let (__storage_var_temp0) = storage_read(address=storage_addr + 0)\n\n tempvar syscall_ptr = syscall_ptr\n tempvar pedersen_ptr = pedersen_ptr\n tempvar range_check_ptr = range_check_ptr\n tempvar __storage_var_temp0 : felt = __storage_var_temp0\n return ([cast(&__storage_var_temp0, felt*)])\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(value : felt):\n let (storage_addr) = addr()\n storage_write(address=storage_addr + 0, value=[cast(&value, felt) + 0])\n return ()\n end\nend", + "autogen/starknet/storage_var/candidates/decl.cairo": "namespace candidates:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}(account : felt) -> (res : felt):\n let res = 0\n call hash2\n call normalize_address\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(\n account : felt\n ) -> (governance_candidate : felt):\n let storage_addr = 0\n call addr\n call storage_read\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(\n account : felt, value : felt\n ):\n let storage_addr = 0\n call addr\n call storage_write\n end\nend", + "autogen/starknet/storage_var/candidates/impl.cairo": "namespace candidates:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}(account : felt) -> (res : felt):\n let res = 966177859921636613857551828317341072452675568526713113397521978082421626481\n let (res) = hash2{hash_ptr=pedersen_ptr}(res, cast(&account, felt*)[0])\n let (res) = normalize_address(addr=res)\n return (res=res)\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(\n account : felt\n ) -> (governance_candidate : felt):\n let (storage_addr) = addr(account)\n let (__storage_var_temp0) = storage_read(address=storage_addr + 0)\n\n tempvar syscall_ptr = syscall_ptr\n tempvar pedersen_ptr = pedersen_ptr\n tempvar range_check_ptr = range_check_ptr\n tempvar __storage_var_temp0 : felt = __storage_var_temp0\n return ([cast(&__storage_var_temp0, felt*)])\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(\n account : felt, value : felt\n ):\n let (storage_addr) = addr(account)\n storage_write(address=storage_addr + 0, value=[cast(&value, felt) + 0])\n return ()\n end\nend", + "autogen/starknet/storage_var/class_hash/decl.cairo": "namespace class_hash:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt):\n let res = 0\n call hash2\n call normalize_address\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (hash : felt):\n let storage_addr = 0\n call addr\n call storage_read\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(value : felt):\n let storage_addr = 0\n call addr\n call storage_write\n end\nend", + "autogen/starknet/storage_var/class_hash/impl.cairo": "namespace class_hash:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt):\n let res = 804666544281051962778212893160482631188027994552534763227229495077610776939\n return (res=res)\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (hash : felt):\n let (storage_addr) = addr()\n let (__storage_var_temp0) = storage_read(address=storage_addr + 0)\n\n tempvar syscall_ptr = syscall_ptr\n tempvar pedersen_ptr = pedersen_ptr\n tempvar range_check_ptr = range_check_ptr\n tempvar __storage_var_temp0 : felt = __storage_var_temp0\n return ([cast(&__storage_var_temp0, felt*)])\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(value : felt):\n let (storage_addr) = addr()\n storage_write(address=storage_addr + 0, value=[cast(&value, felt) + 0])\n return ()\n end\nend", + "autogen/starknet/storage_var/governance_initialized/decl.cairo": "namespace governance_initialized:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt):\n let res = 0\n call hash2\n call normalize_address\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (\n initialized : felt\n ):\n let storage_addr = 0\n call addr\n call storage_read\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(value : felt):\n let storage_addr = 0\n call addr\n call storage_write\n end\nend", + "autogen/starknet/storage_var/governance_initialized/impl.cairo": "namespace governance_initialized:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt):\n let res = 411649891831311481866083863803283943759912575680088837133421096357856968326\n return (res=res)\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (\n initialized : felt\n ):\n let (storage_addr) = addr()\n let (__storage_var_temp0) = storage_read(address=storage_addr + 0)\n\n tempvar syscall_ptr = syscall_ptr\n tempvar pedersen_ptr = pedersen_ptr\n tempvar range_check_ptr = range_check_ptr\n tempvar __storage_var_temp0 : felt = __storage_var_temp0\n return ([cast(&__storage_var_temp0, felt*)])\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(value : felt):\n let (storage_addr) = addr()\n storage_write(address=storage_addr + 0, value=[cast(&value, felt) + 0])\n return ()\n end\nend", + "autogen/starknet/storage_var/governors/decl.cairo": "namespace governors:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}(account : felt) -> (res : felt):\n let res = 0\n call hash2\n call normalize_address\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(\n account : felt\n ) -> (active_governor : felt):\n let storage_addr = 0\n call addr\n call storage_read\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(\n account : felt, value : felt\n ):\n let storage_addr = 0\n call addr\n call storage_write\n end\nend", + "autogen/starknet/storage_var/governors/impl.cairo": "namespace governors:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}(account : felt) -> (res : felt):\n let res = 473174039777172977791438085456091829006435644020130570266323097166155133896\n let (res) = hash2{hash_ptr=pedersen_ptr}(res, cast(&account, felt*)[0])\n let (res) = normalize_address(addr=res)\n return (res=res)\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(\n account : felt\n ) -> (active_governor : felt):\n let (storage_addr) = addr(account)\n let (__storage_var_temp0) = storage_read(address=storage_addr + 0)\n\n tempvar syscall_ptr = syscall_ptr\n tempvar pedersen_ptr = pedersen_ptr\n tempvar range_check_ptr = range_check_ptr\n tempvar __storage_var_temp0 : felt = __storage_var_temp0\n return ([cast(&__storage_var_temp0, felt*)])\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(\n account : felt, value : felt\n ):\n let (storage_addr) = addr(account)\n storage_write(address=storage_addr + 0, value=[cast(&value, felt) + 0])\n return ()\n end\nend", + "autogen/starknet/storage_var/impl_activation_time/decl.cairo": "namespace impl_activation_time:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}(key : felt) -> (res : felt):\n let res = 0\n call hash2\n call normalize_address\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(key : felt) -> (\n ready_time : felt\n ):\n let storage_addr = 0\n call addr\n call storage_read\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(\n key : felt, value : felt\n ):\n let storage_addr = 0\n call addr\n call storage_write\n end\nend", + "autogen/starknet/storage_var/impl_activation_time/impl.cairo": "namespace impl_activation_time:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}(key : felt) -> (res : felt):\n let res = 757185127176008445256423207506255876365889208688465503676412510933688902981\n let (res) = hash2{hash_ptr=pedersen_ptr}(res, cast(&key, felt*)[0])\n let (res) = normalize_address(addr=res)\n return (res=res)\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(key : felt) -> (\n ready_time : felt\n ):\n let (storage_addr) = addr(key)\n let (__storage_var_temp0) = storage_read(address=storage_addr + 0)\n\n tempvar syscall_ptr = syscall_ptr\n tempvar pedersen_ptr = pedersen_ptr\n tempvar range_check_ptr = range_check_ptr\n tempvar __storage_var_temp0 : felt = __storage_var_temp0\n return ([cast(&__storage_var_temp0, felt*)])\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(\n key : felt, value : felt\n ):\n let (storage_addr) = addr(key)\n storage_write(address=storage_addr + 0, value=[cast(&value, felt) + 0])\n return ()\n end\nend", + "autogen/starknet/storage_var/upgrade_delay/decl.cairo": "namespace upgrade_delay:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt):\n let res = 0\n call hash2\n call normalize_address\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (\n delay_seconds : felt\n ):\n let storage_addr = 0\n call addr\n call storage_read\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(value : felt):\n let storage_addr = 0\n call addr\n call storage_write\n end\nend", + "autogen/starknet/storage_var/upgrade_delay/impl.cairo": "namespace upgrade_delay:\n from starkware.starknet.common.storage import normalize_address\n from starkware.starknet.common.syscalls import storage_read, storage_write\n from starkware.cairo.common.cairo_builtins import HashBuiltin\n from starkware.cairo.common.hash import hash2\n\n func addr{pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (res : felt):\n let res = 112691762003367666990514078335904576139457736111203235783537794266546875388\n return (res=res)\n end\n\n func read{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}() -> (\n delay_seconds : felt\n ):\n let (storage_addr) = addr()\n let (__storage_var_temp0) = storage_read(address=storage_addr + 0)\n\n tempvar syscall_ptr = syscall_ptr\n tempvar pedersen_ptr = pedersen_ptr\n tempvar range_check_ptr = range_check_ptr\n tempvar __storage_var_temp0 : felt = __storage_var_temp0\n return ([cast(&__storage_var_temp0, felt*)])\n end\n\n func write{syscall_ptr : felt*, pedersen_ptr : HashBuiltin*, range_check_ptr}(value : felt):\n let (storage_addr) = addr()\n storage_write(address=storage_addr + 0, value=[cast(&value, felt) + 0])\n return ()\n end\nend" + }, + "instruction_locations": { + "0": { + "accessible_scopes": [ + "starkware.cairo.common.alloc", + "starkware.cairo.common.alloc.alloc" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/alloc.cairo" + }, + "start_col": 5, + "start_line": 3 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 12, + "end_line": 4, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/alloc.cairo" + }, + "start_col": 5, + "start_line": 4 + } + }, + "2": { + "accessible_scopes": [ + "starkware.cairo.common.alloc", + "starkware.cairo.common.alloc.alloc" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 5, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/alloc.cairo" + }, + "start_col": 5, + "start_line": 5 + } + }, + "3": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 14, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 14 + } + }, + "4": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 15, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 15 + } + }, + "5": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 17, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 13, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 18, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 18 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 12, + "start_line": 13 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 20, + "start_line": 17 + } + }, + "7": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 16, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 18, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "start_col": 20, + "start_line": 18 + }, + "While expanding the reference 'result' in:" + ], + "start_col": 18, + "start_line": 16 + } + }, + "8": { + "accessible_scopes": [ + "starkware.cairo.common.hash", + "starkware.cairo.common.hash.hash2" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 18, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "start_col": 5, + "start_line": 18 + } + }, + "9": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 8, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 8 + } + }, + "11": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 9, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 9, + "start_line": 9 + } + }, + "12": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 41, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 12 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 2, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 13, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 35, + "start_line": 13 + }, + "While expanding the reference 'dst' in:" + ], + "start_col": 13, + "start_line": 2 + } + }, + "13": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 2, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 13, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 44, + "start_line": 13 + }, + "While expanding the reference 'src' in:" + ], + "start_col": 26, + "start_line": 2 + } + }, + "14": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 17, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 26, + "start_line": 17 + } + }, + "15": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 17, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 17 + } + }, + "16": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 22, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 22 + } + }, + "18": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 23, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 23 + } + }, + "20": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 27, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 24 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 44, + "end_line": 29, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 29 + } + }, + "22": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 31, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 31 + } + }, + "23": { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 26, + "end_line": 33, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 33 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 14, + "end_line": 34, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/memcpy.cairo" + }, + "start_col": 5, + "start_line": 34 + } + }, + "24": { + "accessible_scopes": [ + "starkware.cairo.lang.compiler.lib.registers", + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 6, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/lang/compiler/lib/registers.cairo" + }, + "start_col": 5, + "start_line": 6 + } + }, + "25": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_not_zero" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 9, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 5 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 7, + "end_line": 10, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 10 + } + }, + "27": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_not_zero" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 9, + "start_line": 12 + } + }, + "29": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_not_zero" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 15, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 15 + } + }, + "30": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_not_equal" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 29, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 20 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 14, + "end_line": 30, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 8, + "start_line": 30 + } + }, + "31": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_not_equal" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 30, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 30 + } + }, + "33": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_not_equal" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 9, + "start_line": 32 + } + }, + "35": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_not_equal" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 35, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 35 + } + }, + "36": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 44, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 40 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 26, + "end_line": 45, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 45 + } + }, + "37": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 46, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 39, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 47, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 47 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 39 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 27, + "start_line": 46 + } + }, + "39": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 47, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 47 + } + }, + "40": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 51, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 39, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 52, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 52 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 39 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 51 + } + }, + "41": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 52, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 15, + "start_line": 52 + } + }, + "42": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 52, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 52 + } + }, + "44": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_le" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 53, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 53 + } + }, + "45": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 104, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 95 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 36, + "start_line": 106 + } + }, + "47": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 93, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 106, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 53, + "start_line": 106 + }, + "While expanding the reference 'high' in:" + ], + "start_col": 16, + "start_line": 93 + } + }, + "48": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 106, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 36, + "start_line": 106 + } + }, + "49": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 106, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 106 + } + }, + "50": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 93, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 111, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 20, + "start_line": 111 + }, + "While expanding the reference 'high' in:" + ], + "start_col": 16, + "start_line": 93 + } + }, + "51": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 111, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 20, + "start_line": 111 + } + }, + "53": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 92, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 111, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 35, + "start_line": 111 + }, + "While expanding the reference 'low' in:" + ], + "start_col": 15, + "start_line": 92 + } + }, + "54": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 111, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 111 + } + }, + "55": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 113, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 87, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 114, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 114 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 21, + "start_line": 87 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 27, + "start_line": 113 + } + }, + "57": { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 114, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "start_col": 5, + "start_line": 114 + } + }, + "58": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 13, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 5, + "start_line": 13 + } + }, + "60": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 7, + "end_line": 21, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 5, + "start_line": 14 + }, + "n_prefix_newlines": 1 + } + ], + "inst": { + "end_col": 7, + "end_line": 22, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 5, + "start_line": 22 + } + }, + "62": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 87, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 50, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 9, + "start_line": 50 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 21, + "start_line": 87 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 12 + } + }, + "63": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 48, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 50, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 24, + "start_line": 50 + }, + "While expanding the reference 'x' in:" + ], + "start_col": 17, + "start_line": 48 + } + }, + "65": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 50, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 9, + "start_line": 50 + } + }, + "67": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 49, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 51, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 24, + "start_line": 51 + }, + "While expanding the reference 'y' in:" + ], + "start_col": 18, + "start_line": 49 + } + }, + "69": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 87, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 50, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 87, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 51, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 9, + "start_line": 51 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 21, + "start_line": 87 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 9, + "start_line": 50 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 21, + "start_line": 87 + } + }, + "70": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 49, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 51, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 24, + "start_line": 51 + }, + "While expanding the reference 'y' in:" + ], + "start_col": 17, + "start_line": 49 + } + }, + "71": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 51, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 9, + "start_line": 51 + } + }, + "73": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 52, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 21, + "start_line": 52 + } + }, + "75": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 52, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 9, + "start_line": 52 + } + }, + "76": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 23, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 9, + "start_line": 23 + } + }, + "78": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 57, + "end_line": 24, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 9, + "start_line": 24 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 11, + "end_line": 25, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 9, + "start_line": 25 + } + }, + "80": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 30, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 13, + "start_line": 30 + } + }, + "82": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 32, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 28, + "start_line": 32 + } + }, + "84": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 87, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 32, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 13, + "start_line": 32 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 21, + "start_line": 87 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 12 + } + }, + "85": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 32, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 28, + "start_line": 32 + } + }, + "86": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 32, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 13, + "start_line": 32 + } + }, + "88": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 11, + "end_line": 25, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 9, + "start_line": 25 + } + }, + "90": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 26, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 13, + "start_line": 26 + } + }, + "92": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 87, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 28, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 13, + "start_line": 28 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 21, + "start_line": 87 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 12 + } + }, + "93": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 52, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 28, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 28, + "start_line": 28 + }, + "While expanding the reference 'addr' in:" + ], + "start_col": 41, + "start_line": 12 + } + }, + "94": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 28, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 13, + "start_line": 28 + } + }, + "96": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 52, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 34, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 21, + "start_line": 34 + }, + "While expanding the reference 'addr' in:" + ], + "start_col": 41, + "start_line": 12 + } + }, + "97": { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "start_col": 9, + "start_line": 34 + } + }, + "98": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 89, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 18, + "start_line": 89 + } + }, + "100": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 88 + } + }, + "101": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 88 + } + }, + "102": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 88 + } + }, + "103": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 88 + } + }, + "104": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 88 + } + }, + "105": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 87, + "end_line": 94, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 94 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 53, + "end_line": 97, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 84, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 74, + "end_line": 98, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 98 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 84 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 23, + "start_line": 97 + } + }, + "107": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 98, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 26, + "start_line": 98 + } + }, + "108": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 98, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 57, + "start_line": 98 + } + }, + "109": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 98, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 98 + } + }, + "110": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 110, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 18, + "start_line": 110 + } + }, + "112": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 114, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 109 + } + }, + "113": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 114, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 109 + } + }, + "114": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 114, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 109 + } + }, + "115": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 114, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 109 + } + }, + "116": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 114, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 109 + } + }, + "117": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 98, + "end_line": 115, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 115 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 53, + "end_line": 118, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 105, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 74, + "end_line": 119, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 119 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 30, + "start_line": 105 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 23, + "start_line": 118 + } + }, + "119": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 119, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 26, + "start_line": 119 + } + }, + "120": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 119, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 57, + "start_line": 119 + } + }, + "121": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 119, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 119 + } + }, + "122": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_caller_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 90, + "end_line": 196, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 63, + "start_line": 196 + } + }, + "124": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_caller_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 91, + "end_line": 196, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 196 + } + }, + "125": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_caller_address" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 93, + "end_line": 197, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 197 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 58, + "end_line": 198, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 199, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 199 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 23, + "start_line": 198 + } + }, + "127": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_caller_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 199, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 28, + "start_line": 199 + } + }, + "128": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_caller_address" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 199, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 199 + } + }, + "129": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_block_timestamp" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 92, + "end_line": 294, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 64, + "start_line": 294 + } + }, + "131": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_block_timestamp" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 93, + "end_line": 294, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 294 + } + }, + "132": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_block_timestamp" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 94, + "end_line": 295, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 295 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 59, + "end_line": 296, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 292, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 297, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 297 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 292 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 23, + "start_line": 296 + } + }, + "134": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_block_timestamp" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 297, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 29, + "start_line": 297 + } + }, + "135": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_block_timestamp" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 62, + "end_line": 297, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 297 + } + }, + "136": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 348, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 58, + "start_line": 348 + } + }, + "138": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 97, + "end_line": 348, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 348 + } + }, + "139": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 97, + "end_line": 348, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 348 + } + }, + "140": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 87, + "end_line": 349, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 349 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 53, + "end_line": 351, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 352, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 352 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 23, + "start_line": 351 + } + }, + "142": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 352, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 19, + "start_line": 352 + } + }, + "143": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 352, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 352 + } + }, + "144": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 366, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 18, + "start_line": 366 + } + }, + "146": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 366, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 365 + } + }, + "147": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 366, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 365 + } + }, + "148": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 366, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 365 + } + }, + "149": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 88, + "end_line": 367, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 367 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 54, + "end_line": 368, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 364, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 369, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 369 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 364 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 23, + "start_line": 368 + } + }, + "151": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 369, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 369 + } + }, + "152": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.emit_event" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 385, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 18, + "start_line": 385 + } + }, + "154": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.emit_event" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 98, + "end_line": 385, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 384 + } + }, + "155": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.emit_event" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 98, + "end_line": 385, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 384 + } + }, + "156": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.emit_event" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 98, + "end_line": 385, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 384 + } + }, + "157": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.emit_event" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 98, + "end_line": 385, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 384 + } + }, + "158": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.emit_event" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 98, + "end_line": 385, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 384 + } + }, + "159": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.emit_event" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 85, + "end_line": 386, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 386 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 51, + "end_line": 387, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 383, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 388, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 388 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 383 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 23, + "start_line": 387 + } + }, + "161": { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.emit_event" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 388, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "start_col": 5, + "start_line": 388 + } + }, + "162": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "163": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "164": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 21, + "start_line": 9 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 19, + "start_line": 8 + } + }, + "166": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + } + }, + "167": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 30, + "start_line": 13 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 12 + } + }, + "168": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 30, + "start_line": 13 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 12 + } + }, + "169": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 30, + "start_line": 13 + } + }, + "171": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 37, + "start_line": 14 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 12 + } + }, + "172": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 58, + "start_line": 14 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 13 + } + }, + "173": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 37, + "start_line": 14 + } + }, + "175": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 31, + "start_line": 16 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 37, + "start_line": 14 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + } + }, + "176": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 32, + "start_line": 17 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 13 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "177": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 35, + "start_line": 18 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 13 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "178": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 46, + "start_line": 19 + }, + "While expanding the reference '__storage_var_temp0' in:" + ], + "start_col": 14, + "start_line": 14 + } + }, + "179": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 20, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 9, + "start_line": 20 + } + }, + "180": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 30, + "start_line": 24 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 23 + } + }, + "181": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 30, + "start_line": 24 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 23 + } + }, + "182": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 30, + "start_line": 24 + } + }, + "184": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 364, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 9, + "start_line": 25 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 364 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 23 + } + }, + "185": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 31, + "start_line": 25 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 24 + } + }, + "186": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 55, + "start_line": 25 + } + }, + "187": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 9, + "start_line": 25 + } + }, + "189": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 9, + "start_line": 26 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 19 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 24 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "190": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 9, + "start_line": 26 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 19 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 24 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "191": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/impl.cairo" + }, + "start_col": 9, + "start_line": 26 + } + }, + "192": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 12, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 17, + "start_line": 12 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 11 + } + }, + "193": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 12, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 17, + "start_line": 12 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 11 + } + }, + "194": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/_finalized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 12, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 17, + "start_line": 12 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 11 + } + }, + "195": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 12, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 17, + "start_line": 12 + } + }, + "197": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 13 + } + }, + "198": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized_encode_return" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/return/finalized/291398c85e3156ab9c7a7286de7b4369dea58653d1e9a6668df867ac82fc77cc.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 3 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 17, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/return/finalized/291398c85e3156ab9c7a7286de7b4369dea58653d1e9a6668df867ac82fc77cc.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 4 + } + }, + "200": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/a46542dc358872d57a2d9f424e61d9b07a0e4c72f24e3645022494cebfb47c83.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 89, + "start_line": 11 + }, + "While handling return value 'res'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "201": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/a46542dc358872d57a2d9f424e61d9b07a0e4c72f24e3645022494cebfb47c83.cairo" + }, + "parent_location": [ + { + "end_col": 99, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/external/return/finalized/291398c85e3156ab9c7a7286de7b4369dea58653d1e9a6668df867ac82fc77cc.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While handling return value of" + ], + "start_col": 18, + "start_line": 11 + }, + "While expanding the reference '__return_value_ptr' in:" + ], + "start_col": 89, + "start_line": 11 + }, + "While handling return value 'res'" + ], + "start_col": 26, + "start_line": 2 + } + }, + "203": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/return/finalized/291398c85e3156ab9c7a7286de7b4369dea58653d1e9a6668df867ac82fc77cc.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/external/return/finalized/291398c85e3156ab9c7a7286de7b4369dea58653d1e9a6668df867ac82fc77cc.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While handling return value of" + ], + "start_col": 25, + "start_line": 10 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 11 + }, + "While handling return value of" + ], + "start_col": 56, + "start_line": 1 + } + }, + "204": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/external/return/finalized/291398c85e3156ab9c7a7286de7b4369dea58653d1e9a6668df867ac82fc77cc.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While handling return value of" + ], + "start_col": 18, + "start_line": 11 + } + }, + "205": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/external/return/finalized/291398c85e3156ab9c7a7286de7b4369dea58653d1e9a6668df867ac82fc77cc.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/external/return/finalized/291398c85e3156ab9c7a7286de7b4369dea58653d1e9a6668df867ac82fc77cc.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While handling return value of" + ], + "start_col": 14, + "start_line": 12 + }, + "While expanding the reference '__return_value_ptr_start' in:" + ], + "start_col": 6, + "start_line": 11 + }, + "While handling return value of" + ], + "start_col": 11, + "start_line": 5 + } + }, + "206": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/external/return/finalized/291398c85e3156ab9c7a7286de7b4369dea58653d1e9a6668df867ac82fc77cc.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 9 + } + }, + "207": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "208": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "209": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "210": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "211": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + } + }, + "213": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 98, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 83, + "start_line": 2 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "214": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 99, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 48, + "start_line": 2 + } + }, + "216": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "217": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "218": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "219": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 2 + } + }, + "220": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/finalized/15c361411bb1e61bbf1a9f54960fefb184b7f514be369e14ff547a00198fd614.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 37, + "start_line": 2 + } + }, + "221": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/finalized/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 15, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 6, + "start_line": 11 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "222": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 17, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 31, + "start_line": 17 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 11 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 16 + } + }, + "223": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 17, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 31, + "start_line": 17 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 11 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 16 + } + }, + "224": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 17, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 31, + "start_line": 17 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 11 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 16 + } + }, + "225": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 17, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 31, + "start_line": 17 + } + }, + "227": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 19, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 9, + "start_line": 19 + } + }, + "229": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 17, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 21, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 21 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 16 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 31, + "start_line": 17 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 11 + } + }, + "230": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 17, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 21, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 21 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 16 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 31, + "start_line": 17 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 11 + } + }, + "231": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 11, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 17, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 21, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 21 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 16 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 31, + "start_line": 17 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 11 + } + }, + "232": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 21, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 21 + } + }, + "233": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 25, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 25 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 16 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 24 + } + }, + "234": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 25, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 25 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 16 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 24 + } + }, + "235": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 25, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 25 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 16 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 24 + } + }, + "236": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 25, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 25 + } + }, + "238": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 26, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 22, + "start_line": 26 + } + }, + "240": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 26, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 26 + } + }, + "242": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "start_col": 5, + "start_line": 27 + } + }, + "243": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "244": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "245": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 94, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 21, + "start_line": 9 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 19, + "start_line": 8 + } + }, + "247": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + } + }, + "248": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 30, + "start_line": 15 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 12 + } + }, + "249": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 30, + "start_line": 15 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 12 + } + }, + "250": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 30, + "start_line": 15 + } + }, + "252": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 37, + "start_line": 16 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 12 + } + }, + "253": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 58, + "start_line": 16 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 15 + } + }, + "254": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 37, + "start_line": 16 + } + }, + "256": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 31, + "start_line": 18 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 37, + "start_line": 16 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + } + }, + "257": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 32, + "start_line": 19 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 15 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "258": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 20, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 35, + "start_line": 20 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 15 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "259": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 46, + "start_line": 21 + }, + "While expanding the reference '__storage_var_temp0' in:" + ], + "start_col": 14, + "start_line": 16 + } + }, + "260": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 22, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 9, + "start_line": 22 + } + }, + "261": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 30, + "start_line": 26 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 25 + } + }, + "262": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 30, + "start_line": 26 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 25 + } + }, + "263": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 30, + "start_line": 26 + } + }, + "265": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 364, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 9, + "start_line": 27 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 364 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 25 + } + }, + "266": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 31, + "start_line": 27 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 26 + } + }, + "267": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 55, + "start_line": 27 + } + }, + "268": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 9, + "start_line": 27 + } + }, + "270": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 28, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 9, + "start_line": 28 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 26 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "271": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 28, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 9, + "start_line": 28 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 26 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "272": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 28, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/impl.cairo" + }, + "start_col": 9, + "start_line": 28 + } + }, + "273": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 36, + "start_line": 9 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "274": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 94, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 50, + "start_line": 9 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 19, + "start_line": 8 + } + }, + "276": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 55, + "start_line": 9 + } + }, + "277": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 21, + "start_line": 9 + } + }, + "279": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 21, + "start_line": 10 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 12 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "280": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 44, + "start_line": 10 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 14, + "start_line": 9 + } + }, + "281": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 21, + "start_line": 10 + } + }, + "283": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 9, + "start_line": 11 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 9 + } + }, + "284": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 9, + "start_line": 11 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 21, + "start_line": 10 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 12 + } + }, + "285": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 21, + "start_line": 11 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 14, + "start_line": 10 + } + }, + "286": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 9, + "start_line": 11 + } + }, + "287": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 30, + "start_line": 17 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 14 + } + }, + "288": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 30, + "start_line": 17 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 14 + } + }, + "289": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 35, + "start_line": 17 + }, + "While expanding the reference 'account' in:" + ], + "start_col": 9, + "start_line": 15 + } + }, + "290": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 30, + "start_line": 17 + } + }, + "292": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 37, + "start_line": 18 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 14 + } + }, + "293": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 58, + "start_line": 18 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 17 + } + }, + "294": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 37, + "start_line": 18 + } + }, + "296": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 20, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 31, + "start_line": 20 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 37, + "start_line": 18 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + } + }, + "297": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 32, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 17 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "298": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 22, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 35, + "start_line": 22 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 17 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "299": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 46, + "start_line": 23 + }, + "While expanding the reference '__storage_var_temp0' in:" + ], + "start_col": 14, + "start_line": 18 + } + }, + "300": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 9, + "start_line": 24 + } + }, + "301": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 30, + "start_line": 30 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 27 + } + }, + "302": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 30, + "start_line": 30 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 27 + } + }, + "303": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 28, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 35, + "start_line": 30 + }, + "While expanding the reference 'account' in:" + ], + "start_col": 9, + "start_line": 28 + } + }, + "304": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 30, + "start_line": 30 + } + }, + "306": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 364, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 9, + "start_line": 31 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 364 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 27 + } + }, + "307": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 31, + "start_line": 31 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 30 + } + }, + "308": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 55, + "start_line": 31 + } + }, + "309": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 9, + "start_line": 31 + } + }, + "311": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 9, + "start_line": 32 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 30 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "312": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 9, + "start_line": 32 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 30 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "313": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/impl.cairo" + }, + "start_col": 9, + "start_line": 32 + } + }, + "314": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 36, + "start_line": 9 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "315": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 94, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 50, + "start_line": 9 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 19, + "start_line": 8 + } + }, + "317": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 55, + "start_line": 9 + } + }, + "318": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 21, + "start_line": 9 + } + }, + "320": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 21, + "start_line": 10 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 12 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "321": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 44, + "start_line": 10 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 14, + "start_line": 9 + } + }, + "322": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 21, + "start_line": 10 + } + }, + "324": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 9, + "start_line": 11 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 9 + } + }, + "325": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 9, + "start_line": 11 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 21, + "start_line": 10 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 12 + } + }, + "326": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 21, + "start_line": 11 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 14, + "start_line": 10 + } + }, + "327": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 9, + "start_line": 11 + } + }, + "328": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 30, + "start_line": 17 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 14 + } + }, + "329": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 30, + "start_line": 17 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 14 + } + }, + "330": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 35, + "start_line": 17 + }, + "While expanding the reference 'account' in:" + ], + "start_col": 9, + "start_line": 15 + } + }, + "331": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 30, + "start_line": 17 + } + }, + "333": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 37, + "start_line": 18 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 14 + } + }, + "334": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 58, + "start_line": 18 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 17 + } + }, + "335": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 37, + "start_line": 18 + } + }, + "337": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 20, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 31, + "start_line": 20 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 37, + "start_line": 18 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + } + }, + "338": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 32, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 17 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "339": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 22, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 35, + "start_line": 22 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 17 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "340": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 46, + "start_line": 23 + }, + "While expanding the reference '__storage_var_temp0' in:" + ], + "start_col": 14, + "start_line": 18 + } + }, + "341": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 9, + "start_line": 24 + } + }, + "342": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 30, + "start_line": 30 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 27 + } + }, + "343": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 30, + "start_line": 30 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 27 + } + }, + "344": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 28, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 35, + "start_line": 30 + }, + "While expanding the reference 'account' in:" + ], + "start_col": 9, + "start_line": 28 + } + }, + "345": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 30, + "start_line": 30 + } + }, + "347": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 364, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 9, + "start_line": 31 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 364 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 27 + } + }, + "348": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 31, + "start_line": 31 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 30 + } + }, + "349": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 55, + "start_line": 31 + } + }, + "350": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 9, + "start_line": 31 + } + }, + "352": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 9, + "start_line": 32 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 30 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "353": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 9, + "start_line": 32 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 30 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "354": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates", + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/impl.cairo" + }, + "start_col": 9, + "start_line": 32 + } + }, + "355": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "357": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 2 + } + }, + "359": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "360": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 23, + "start_line": 3 + } + }, + "362": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "363": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 4 + } + }, + "365": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 4 + } + }, + "366": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/492648d59c697ae70640b4e48da59ebd65103052828f6145a8284bc82314cf20.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 25, + "start_line": 22 + }, + "While handling calldata argument 'new_governor_nominee'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "367": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/b81f27b64c06a9309a49596002ea7e11631cc26feee830846c7da27aeff0e17a.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 54, + "start_line": 22 + }, + "While handling calldata argument 'nominated_by'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "368": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/b81f27b64c06a9309a49596002ea7e11631cc26feee830846c7da27aeff0e17a.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 54, + "start_line": 22 + }, + "While handling calldata argument 'nominated_by'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "370": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 383, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 383 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "371": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 21, + "start_line": 1 + } + }, + "373": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 29, + "start_line": 1 + }, + "While expanding the reference '__keys_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 2 + } + }, + "374": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + } + }, + "375": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 94, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 84, + "start_line": 1 + }, + "While expanding the reference '__data_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 4 + } + }, + "376": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "378": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "379": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "380": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "382": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 2 + } + }, + "384": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "385": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 23, + "start_line": 3 + } + }, + "387": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "388": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 4 + } + }, + "390": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 4 + } + }, + "391": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/17d835e5cff16987ba8eac1ec2a57cba4582fa1aaa6b2abcd6da5afc89692c9e.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 27 + }, + "While handling calldata argument 'cancelled_nominee'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "392": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/24c97f670ce31f815c23d458c5a6051e4b7ba12ac09ee0df538993191f984906.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 53, + "start_line": 27 + }, + "While handling calldata argument 'cancelled_by'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "393": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/24c97f670ce31f815c23d458c5a6051e4b7ba12ac09ee0df538993191f984906.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 53, + "start_line": 27 + }, + "While handling calldata argument 'cancelled_by'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "395": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 383, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 383 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "396": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 21, + "start_line": 1 + } + }, + "398": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 29, + "start_line": 1 + }, + "While expanding the reference '__keys_ptr' in:" + ], + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 2 + } + }, + "399": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + } + }, + "400": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 94, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 84, + "start_line": 1 + }, + "While expanding the reference '__data_ptr' in:" + ], + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 4 + } + }, + "401": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "403": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "404": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "405": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "407": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 2 + } + }, + "409": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "410": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 23, + "start_line": 3 + } + }, + "412": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "413": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 4 + } + }, + "415": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 4 + } + }, + "416": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/2e595849d73b71aa109f5f1d3c29c013eb1dd58b510c79ea714007d20cece32a.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 23, + "start_line": 32 + }, + "While handling calldata argument 'removed_governor'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "417": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6a9e5474458c08b7b096934bef7fcca112846641f1e280aadf6f50bafc4a5bc0.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 48, + "start_line": 32 + }, + "While handling calldata argument 'removed_by'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "418": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/6a9e5474458c08b7b096934bef7fcca112846641f1e280aadf6f50bafc4a5bc0.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 48, + "start_line": 32 + }, + "While handling calldata argument 'removed_by'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "420": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 383, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 383 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "421": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 21, + "start_line": 1 + } + }, + "423": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 29, + "start_line": 1 + }, + "While expanding the reference '__keys_ptr' in:" + ], + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 2 + } + }, + "424": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + } + }, + "425": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 94, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 84, + "start_line": 1 + }, + "While expanding the reference '__data_ptr' in:" + ], + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 4 + } + }, + "426": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "428": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "429": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "430": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "432": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 2 + } + }, + "434": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "435": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 23, + "start_line": 3 + } + }, + "437": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "438": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 4 + } + }, + "440": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 4 + } + }, + "441": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/363b233a7c697e07ee6a6af6c2ddef3c46ae0133d641833917804d0ad89c4a8d.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 37 + }, + "While handling calldata argument 'new_governor'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "442": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/363b233a7c697e07ee6a6af6c2ddef3c46ae0133d641833917804d0ad89c4a8d.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 26, + "start_line": 37 + }, + "While handling calldata argument 'new_governor'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "444": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 383, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 383 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "445": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 21, + "start_line": 1 + } + }, + "447": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 29, + "start_line": 1 + }, + "While expanding the reference '__keys_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 2 + } + }, + "448": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + } + }, + "449": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 94, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 84, + "start_line": 1 + }, + "While expanding the reference '__data_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 4 + } + }, + "450": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "452": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "453": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted", + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "454": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 44, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 44 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 41 + } + }, + "455": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 44, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 44 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 41 + } + }, + "456": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 83, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 44, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 44 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 41 + } + }, + "457": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 42, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 44, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 49, + "start_line": 44 + }, + "While expanding the reference 'account' in:" + ], + "start_col": 5, + "start_line": 42 + } + }, + "458": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 44, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 44 + } + }, + "460": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 45 + } + }, + "461": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor_encode_return" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/return/is_governor/3595b8bc72801c1e0c0f1a6192e851e961c01fb57f1e1948ae8557d66579a8a7.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 3 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 17, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/return/is_governor/3595b8bc72801c1e0c0f1a6192e851e961c01fb57f1e1948ae8557d66579a8a7.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 4 + } + }, + "463": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/a14f7b648fb3ba6431b9ea0aec1e8e663818e10f9e10eb57b1c38ab239df4db0.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 43, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 7, + "start_line": 43 + }, + "While handling return value 'is_governor_'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "464": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/a14f7b648fb3ba6431b9ea0aec1e8e663818e10f9e10eb57b1c38ab239df4db0.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 43, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/external/return/is_governor/3595b8bc72801c1e0c0f1a6192e851e961c01fb57f1e1948ae8557d66579a8a7.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While handling return value of" + ], + "start_col": 18, + "start_line": 11 + }, + "While expanding the reference '__return_value_ptr' in:" + ], + "start_col": 7, + "start_line": 43 + }, + "While handling return value 'is_governor_'" + ], + "start_col": 26, + "start_line": 2 + } + }, + "466": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/return/is_governor/3595b8bc72801c1e0c0f1a6192e851e961c01fb57f1e1948ae8557d66579a8a7.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/external/return/is_governor/3595b8bc72801c1e0c0f1a6192e851e961c01fb57f1e1948ae8557d66579a8a7.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While handling return value of" + ], + "start_col": 25, + "start_line": 10 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 41 + }, + "While handling return value of" + ], + "start_col": 67, + "start_line": 1 + } + }, + "467": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/external/return/is_governor/3595b8bc72801c1e0c0f1a6192e851e961c01fb57f1e1948ae8557d66579a8a7.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While handling return value of" + ], + "start_col": 18, + "start_line": 11 + } + }, + "468": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/external/return/is_governor/3595b8bc72801c1e0c0f1a6192e851e961c01fb57f1e1948ae8557d66579a8a7.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/external/return/is_governor/3595b8bc72801c1e0c0f1a6192e851e961c01fb57f1e1948ae8557d66579a8a7.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While handling return value of" + ], + "start_col": 14, + "start_line": 12 + }, + "While expanding the reference '__return_value_ptr_start' in:" + ], + "start_col": 6, + "start_line": 41 + }, + "While handling return value of" + ], + "start_col": 11, + "start_line": 5 + } + }, + "469": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/external/return/is_governor/3595b8bc72801c1e0c0f1a6192e851e961c01fb57f1e1948ae8557d66579a8a7.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 9 + } + }, + "470": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/a728d24eb4669a8e6860e6c0a3b4f06e3de9bab90a8ca676c0bcf3c287ac921b.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 42, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/5e1cc73f0b484f90bb02da164d88332b40c6f698801aa4d3c603dab22157e902.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While handling calldata of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__calldata_actual_size' in:" + ], + "start_col": 6, + "start_line": 41 + }, + "While handling calldata of" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 42 + }, + "While handling calldata argument 'account'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "472": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "473": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "474": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "475": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 83, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "476": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/a728d24eb4669a8e6860e6c0a3b4f06e3de9bab90a8ca676c0bcf3c287ac921b.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 42, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 147, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 125, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_account' in:" + ], + "start_col": 5, + "start_line": 42 + }, + "While handling calldata argument 'account'" + ], + "start_col": 30, + "start_line": 1 + } + }, + "477": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + } + }, + "479": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 100, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 85, + "start_line": 2 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "480": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 101, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 48, + "start_line": 2 + } + }, + "482": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "483": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "484": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "485": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 2 + } + }, + "486": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ca441c7635ac75ded565e37cebc5bf0e6fb9e92d91649292940cd372c4a5819.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 37, + "start_line": 2 + } + }, + "487": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/is_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 41 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "488": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 33, + "start_line": 50 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 22, + "start_line": 49 + } + }, + "489": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 70, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 33, + "start_line": 50 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 43, + "start_line": 49 + } + }, + "490": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 87, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 33, + "start_line": 50 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 72, + "start_line": 49 + } + }, + "491": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 62, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 33, + "start_line": 50 + } + }, + "493": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 52, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 52 + } + }, + "495": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 54, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 54 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 33, + "start_line": 50 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + } + }, + "496": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 54, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 54 + } + }, + "498": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 58, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 58 + } + }, + "500": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 54, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 60, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 60 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 27, + "start_line": 54 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + } + }, + "501": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 60, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 60 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 33, + "start_line": 50 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + } + }, + "502": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governance_initialized/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 60, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 60 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 33, + "start_line": 50 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + } + }, + "503": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 60, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 34, + "start_line": 60 + } + }, + "505": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 60, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 60 + } + }, + "507": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 54, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 61, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 29, + "start_line": 61 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 54 + } + }, + "508": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 61, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 43, + "start_line": 61 + } + }, + "510": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 61, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 61 + } + }, + "512": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 61, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 78, + "end_line": 62, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 61 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + } + }, + "513": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 61, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 78, + "end_line": 62, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 62 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 61 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + } + }, + "514": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 54, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 62, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 50, + "start_line": 62 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 54 + } + }, + "515": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 54, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 77, + "end_line": 62, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 71, + "start_line": 62 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 54 + } + }, + "516": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 62, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 62 + } + }, + "518": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 54, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 43, + "start_line": 63 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 54 + } + }, + "519": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 63 + } + }, + "521": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 64, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 64 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 22, + "start_line": 49 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 63 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "522": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 61, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 64, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 64 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 43, + "start_line": 49 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 61 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + } + }, + "523": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 87, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 64, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 64 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 72, + "start_line": 49 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 63 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "524": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 64, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 64 + } + }, + "525": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "526": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 22, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "527": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 43, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "528": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 87, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 72, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "529": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + } + }, + "531": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "533": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "534": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "535": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "536": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "538": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/init_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "539": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/init_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 49 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "540": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 71, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 71 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 28, + "start_line": 68 + } + }, + "541": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 71, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 71 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 49, + "start_line": 68 + } + }, + "542": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 93, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 71, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 71 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 78, + "start_line": 68 + } + }, + "543": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 71, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 71 + } + }, + "545": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 69, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 74, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 38, + "start_line": 74 + }, + "While expanding the reference 'nominee' in:" + ], + "start_col": 5, + "start_line": 69 + } + }, + "546": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 74, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 74 + } + }, + "548": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 76, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 76 + } + }, + "550": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 69, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 81, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 25, + "start_line": 81 + }, + "While expanding the reference 'nominee' in:" + ], + "start_col": 5, + "start_line": 69 + } + }, + "551": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 81, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 81 + } + }, + "553": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 74, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 85 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 74 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 41 + } + }, + "554": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 74, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 85 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 26, + "start_line": 74 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 41 + } + }, + "555": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 83, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 74, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 85 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 26, + "start_line": 74 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 41 + } + }, + "556": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 69, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 30, + "start_line": 85 + }, + "While expanding the reference 'nominee' in:" + ], + "start_col": 5, + "start_line": 69 + } + }, + "557": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 45, + "start_line": 85 + } + }, + "559": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 85 + } + }, + "561": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 86, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 86 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 85 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + } + }, + "562": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 86, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 86 + } + }, + "564": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 86, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 87, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 87 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 27, + "start_line": 86 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + } + }, + "565": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 87, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 87 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 85 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + } + }, + "566": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 69, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 87, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 50, + "start_line": 87 + }, + "While expanding the reference 'nominee' in:" + ], + "start_col": 5, + "start_line": 69 + } + }, + "567": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 86, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 78, + "end_line": 87, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 72, + "start_line": 87 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 86 + } + }, + "568": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 87, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 87 + } + }, + "570": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 87, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 88, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 88 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 28, + "start_line": 68 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 87 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "571": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 88, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 88 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 49, + "start_line": 68 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 85 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + } + }, + "572": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_nominated/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 22, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 87, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 93, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 88, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 88 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 78, + "start_line": 68 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 87 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 22 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "573": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 88, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 88 + } + }, + "574": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/b3dc4f7080ff6316032cfe42a522b2a826c5eaa7df04ae64b32d9b11aeedfda0.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 69, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/5e1cc73f0b484f90bb02da164d88332b40c6f698801aa4d3c603dab22157e902.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While handling calldata of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__calldata_actual_size' in:" + ], + "start_col": 6, + "start_line": 68 + }, + "While handling calldata of" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 69 + }, + "While handling calldata argument 'nominee'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "576": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "577": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 28, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "578": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 49, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "579": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 93, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 78, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "580": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/b3dc4f7080ff6316032cfe42a522b2a826c5eaa7df04ae64b32d9b11aeedfda0.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 69, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 147, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 125, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_nominee' in:" + ], + "start_col": 5, + "start_line": 69 + }, + "While handling calldata argument 'nominee'" + ], + "start_col": 30, + "start_line": 1 + } + }, + "581": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + } + }, + "583": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "585": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "586": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "587": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "588": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "590": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/813e4dc36ee2ff36a6f3c4295160b0effb436ac45c05c1cd223a02efd15bae22.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "591": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/nominate_new_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 68 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "592": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 95, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 95 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 24, + "start_line": 92 + } + }, + "593": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 95, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 95 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 45, + "start_line": 92 + } + }, + "594": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 89, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 95, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 95 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 74, + "start_line": 92 + } + }, + "595": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 95, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 95 + } + }, + "597": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 50, + "start_line": 98 + }, + "While expanding the reference 'cancelee' in:" + ], + "start_col": 5, + "start_line": 93 + } + }, + "598": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 98 + } + }, + "600": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 99, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 99 + } + }, + "602": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 100, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 100 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 24, + "start_line": 92 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 98 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + } + }, + "603": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 72, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 100, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 100 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 45, + "start_line": 92 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 26, + "start_line": 98 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + } + }, + "604": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 89, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 100, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 100 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 74, + "start_line": 92 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 26, + "start_line": 98 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + } + }, + "605": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 100, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 100 + } + }, + "606": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 104, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 104 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 98 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + } + }, + "607": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 104, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 104 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 26, + "start_line": 98 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + } + }, + "608": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 104, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 104 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 26, + "start_line": 98 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + } + }, + "609": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 104, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 30, + "start_line": 104 + }, + "While expanding the reference 'cancelee' in:" + ], + "start_col": 5, + "start_line": 93 + } + }, + "610": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 104, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 46, + "start_line": 104 + } + }, + "612": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 52, + "end_line": 104, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 104 + } + }, + "614": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 104, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 105, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 105 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 104 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + } + }, + "615": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 105, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 105 + } + }, + "617": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 105, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 106 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 27, + "start_line": 105 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + } + }, + "618": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 104, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 106 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 104 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + } + }, + "619": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 49, + "start_line": 106 + }, + "While expanding the reference 'cancelee' in:" + ], + "start_col": 5, + "start_line": 93 + } + }, + "620": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 105, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 78, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 72, + "start_line": 106 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 105 + } + }, + "621": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 106 + } + }, + "623": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 107, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 107 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 24, + "start_line": 92 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 106 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "624": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 104, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 72, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 107, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 107 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 45, + "start_line": 92 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 104 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + } + }, + "625": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/nomination_cancelled/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 89, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 107, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 107 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 74, + "start_line": 92 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 106 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 27 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "626": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 107, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 107 + } + }, + "627": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/8b6bed184f49fa9e870af4864a777f1106d12a9d69a2437bcd6416567487bf13.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/5e1cc73f0b484f90bb02da164d88332b40c6f698801aa4d3c603dab22157e902.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While handling calldata of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__calldata_actual_size' in:" + ], + "start_col": 6, + "start_line": 92 + }, + "While handling calldata of" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 93 + }, + "While handling calldata argument 'cancelee'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "629": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "630": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 24, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "631": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 72, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 45, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "632": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 89, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 74, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "633": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/8b6bed184f49fa9e870af4864a777f1106d12a9d69a2437bcd6416567487bf13.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 149, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 126, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_cancelee' in:" + ], + "start_col": 5, + "start_line": 93 + }, + "While handling calldata argument 'cancelee'" + ], + "start_col": 31, + "start_line": 1 + } + }, + "634": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + } + }, + "636": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "638": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "639": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "640": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "641": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "643": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/aa973b5637e8494316c8c8fe7bc1ef88161a2545a09cbebefcc2292466d4e74f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "644": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/cancel_nomination/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 92 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "645": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 114, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 114 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 22, + "start_line": 111 + } + }, + "646": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 70, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 114, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 114 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 43, + "start_line": 111 + } + }, + "647": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 87, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 114, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 114 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 72, + "start_line": 111 + } + }, + "648": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 114, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 114 + } + }, + "650": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 112, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 116, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 45, + "start_line": 116 + }, + "While expanding the reference 'removee' in:" + ], + "start_col": 5, + "start_line": 112 + } + }, + "651": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 116, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 33, + "start_line": 116 + } + }, + "653": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 118, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 118 + } + }, + "655": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 116, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 121, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 121 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 33, + "start_line": 116 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 41 + } + }, + "656": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 121, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 121 + } + }, + "658": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 112, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 34, + "start_line": 123 + }, + "While expanding the reference 'removee' in:" + ], + "start_col": 5, + "start_line": 112 + } + }, + "659": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 123 + } + }, + "661": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 121, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 126 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 27, + "start_line": 121 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + } + }, + "662": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 116, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 126 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 33, + "start_line": 116 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 41 + } + }, + "663": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 83, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 116, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 126 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 33, + "start_line": 116 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 41 + } + }, + "664": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 112, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 29, + "start_line": 126 + }, + "While expanding the reference 'removee' in:" + ], + "start_col": 5, + "start_line": 112 + } + }, + "665": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 44, + "start_line": 126 + } + }, + "667": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 126 + } + }, + "669": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 71, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 127 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 126 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + } + }, + "670": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 71, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 127 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 126 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + } + }, + "671": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 112, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 44, + "start_line": 127 + }, + "While expanding the reference 'removee' in:" + ], + "start_col": 5, + "start_line": 112 + } + }, + "672": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 121, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 64, + "start_line": 127 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 121 + } + }, + "673": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 127 + } + }, + "675": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 71, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 128, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 128 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 22, + "start_line": 111 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 127 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "676": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 128, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 128 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 43, + "start_line": 111 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 126 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + } + }, + "677": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governor_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 22, + "end_line": 32, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 71, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 87, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 128, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 128 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 72, + "start_line": 111 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 127 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 32 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "678": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 128, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 128 + } + }, + "679": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/f47d2abc24b9c0ac5ed9d831b1926df2a946b6013fa5b67916fb38de8c86d431.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 112, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/5e1cc73f0b484f90bb02da164d88332b40c6f698801aa4d3c603dab22157e902.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While handling calldata of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__calldata_actual_size' in:" + ], + "start_col": 6, + "start_line": 111 + }, + "While handling calldata of" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 112 + }, + "While handling calldata argument 'removee'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "681": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "682": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 22, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "683": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 43, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "684": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 87, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 72, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "685": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/f47d2abc24b9c0ac5ed9d831b1926df2a946b6013fa5b67916fb38de8c86d431.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 112, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 147, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 125, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_removee' in:" + ], + "start_col": 5, + "start_line": 112 + }, + "While handling calldata argument 'removee'" + ], + "start_col": 30, + "start_line": 1 + } + }, + "686": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + } + }, + "688": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "690": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "691": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "692": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "693": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "695": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/adc70706d80dd0d4a3bdbec28a3698a15eb81da7d3d5037b31f01bc945402dad.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "696": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_governor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 111, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 111 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "697": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 133 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 24, + "start_line": 132 + } + }, + "698": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 27, + "start_line": 133 + } + }, + "700": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 136, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 33, + "start_line": 136 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 27, + "start_line": 133 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + } + }, + "701": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 136, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 33, + "start_line": 136 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 45, + "start_line": 132 + } + }, + "702": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 89, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 136, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 33, + "start_line": 136 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 74, + "start_line": 132 + } + }, + "703": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 136, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 57, + "start_line": 136 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 133 + } + }, + "704": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 136, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 33, + "start_line": 136 + } + }, + "706": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 138, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 138 + } + }, + "708": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 136, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 142 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 33, + "start_line": 136 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + } + }, + "709": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 136, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 142 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 33, + "start_line": 136 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + } + }, + "710": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 136, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/candidates/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 142 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 33, + "start_line": 136 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + } + }, + "711": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 30, + "start_line": 142 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 133 + } + }, + "712": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 44, + "start_line": 142 + } + }, + "714": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 142 + } + }, + "716": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 143, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 29, + "start_line": 143 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 133 + } + }, + "717": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 143, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 43, + "start_line": 143 + } + }, + "719": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 143, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 143 + } + }, + "721": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 143, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 144, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 144 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 143 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + } + }, + "722": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 143, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 144, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 144 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 143 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + } + }, + "723": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 144, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 43, + "start_line": 144 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 133 + } + }, + "724": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 144, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 144 + } + }, + "726": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 144, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 145, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 145 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 24, + "start_line": 132 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 144 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "727": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/governors/decl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 143, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 72, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 145, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 145 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 45, + "start_line": 132 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 143 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + } + }, + "728": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/governance_accepted/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 144, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 89, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 145, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 145 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 74, + "start_line": 132 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 144 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 37 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "729": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 145, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 145 + } + }, + "730": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "731": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 24, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "732": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 72, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 45, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "733": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 89, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 74, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "734": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + } + }, + "736": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "738": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "739": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "740": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "741": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "743": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/ef3a79c18d46a9fa62dfdc7620278a45e5a135102b4efbfbcf08b5b08cd0430f.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "744": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/accept_governance/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 23, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 6, + "start_line": 132 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "745": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 149, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 20, + "start_line": 149 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + } + }, + "746": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 149, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 20, + "start_line": 149 + } + }, + "748": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 194, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 149, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 41 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 149 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 194 + } + }, + "749": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 41 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + } + }, + "750": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 83, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 41 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + } + }, + "751": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 149, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 38, + "start_line": 150 + }, + "While expanding the reference 'caller' in:" + ], + "start_col": 10, + "start_line": 149 + } + }, + "752": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 26, + "start_line": 150 + } + }, + "754": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 152, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 9, + "start_line": 152 + } + }, + "756": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 154 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 150 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 41 + } + }, + "757": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 154 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 26, + "start_line": 150 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 41 + } + }, + "758": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 83, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 154 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 26, + "start_line": 150 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 41 + } + }, + "759": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "start_col": 5, + "start_line": 154 + } + }, + "760": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 17, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 17 + } + }, + "762": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 18, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 23, + "start_line": 18 + } + }, + "764": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 20, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 20 + } + }, + "766": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 21, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 21 + } + }, + "768": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 19, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 22, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 29, + "start_line": 22 + }, + "While expanding the reference 'hash_state' in:" + ], + "start_col": 11, + "start_line": 19 + } + }, + "769": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_init" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 22, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 22 + } + }, + "770": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 31, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 31 + } + }, + "772": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 28, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 77, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 34, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 32 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 24, + "start_line": 77 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 28 + } + }, + "773": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 29, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 33, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 33 + }, + "While expanding the reference 'data_ptr' in:" + ], + "start_col": 34, + "start_line": 29 + } + }, + "774": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 29, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 33, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 40, + "start_line": 33 + }, + "While expanding the reference 'data_length' in:" + ], + "start_col": 52, + "start_line": 29 + } + }, + "775": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 33, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 58, + "start_line": 33 + } + }, + "776": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 34, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 32 + } + }, + "778": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 35, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 23, + "start_line": 35 + } + }, + "780": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 37, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 37 + } + }, + "781": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 38, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 37, + "start_line": 38 + } + }, + "782": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 38, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 38 + } + }, + "783": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 77, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 34, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 28, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 39, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 39 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 28 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 32 + }, + "While trying to update the implicit return value 'hash_ptr' in:" + ], + "start_col": 24, + "start_line": 77 + } + }, + "784": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 36, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 39, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 33, + "start_line": 39 + }, + "While expanding the reference 'new_hash_state' in:" + ], + "start_col": 11, + "start_line": 36 + } + }, + "785": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 39, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 39 + } + }, + "786": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 47, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 47 + } + }, + "788": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 44, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 13, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 48, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 48 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 12, + "start_line": 13 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 25, + "start_line": 44 + } + }, + "789": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 48, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 26, + "start_line": 48 + } + }, + "790": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 83, + "end_line": 44, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 61, + "end_line": 48, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 57, + "start_line": 48 + }, + "While expanding the reference 'item' in:" + ], + "start_col": 79, + "start_line": 44 + } + }, + "791": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 62, + "end_line": 48, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 48 + } + }, + "793": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 49, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 23, + "start_line": 49 + } + }, + "795": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 51, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 51 + } + }, + "796": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 52, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 37, + "start_line": 52 + } + }, + "797": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 52, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 52 + } + }, + "799": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 13, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 48, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 44, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 53, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 53 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 25, + "start_line": 44 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 18, + "start_line": 48 + }, + "While trying to update the implicit return value 'hash_ptr' in:" + ], + "start_col": 12, + "start_line": 13 + } + }, + "800": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 50, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 53, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 33, + "start_line": 53 + }, + "While expanding the reference 'new_hash_state' in:" + ], + "start_col": 11, + "start_line": 50 + } + }, + "801": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_single" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 53, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 53 + } + }, + "802": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 69, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 13, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 70, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 70 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 12, + "start_line": 13 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 20, + "start_line": 69 + } + }, + "803": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 70, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 26, + "start_line": 70 + } + }, + "804": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 70, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 57, + "start_line": 70 + } + }, + "805": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 70, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 18, + "start_line": 70 + } + }, + "807": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_finalize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 71, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 71 + } + }, + "808": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 80, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 80 + } + }, + "810": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 77, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 77, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 81, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 9, + "start_line": 81 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 24, + "start_line": 77 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 24, + "start_line": 77 + } + }, + "811": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 78, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 81, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 22, + "start_line": 81 + }, + "While expanding the reference 'hash' in:" + ], + "start_col": 43, + "start_line": 78 + } + }, + "812": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 81, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 9, + "start_line": 81 + } + }, + "813": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 85, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 85 + } + }, + "815": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 86, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 35, + "start_line": 86 + } + }, + "817": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 86, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 86 + } + }, + "818": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 95, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 95 + } + }, + "819": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 96, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 96 + } + }, + "820": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 97, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 97 + } + }, + "821": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 102, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 36, + "start_line": 102 + } + }, + "822": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 105, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 105 + } + }, + "823": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 106, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 37, + "start_line": 106 + } + }, + "824": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 106, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 106 + } + }, + "825": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 110, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 110 + } + }, + "827": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 111, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 111 + } + }, + "829": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 112, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 112 + } + }, + "830": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 115, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 115 + } + }, + "832": { + "accessible_scopes": [ + "starkware.cairo.common.hash_state", + "starkware.cairo.common.hash_state.hash_update_inner" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 120, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "start_col": 5, + "start_line": 120 + } + }, + "833": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "835": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 42, + "start_line": 3 + } + }, + "837": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 6, + "start_line": 3 + } + }, + "838": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 84, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/5c2b7aeab167481680df60350af517363d2959feb2d8d22d44792fc66abecaed.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 84 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 1 + } + }, + "839": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/5c2b7aeab167481680df60350af517363d2959feb2d8d22d44792fc66abecaed.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 16, + "start_line": 3 + }, + "While expanding the reference 'class_hash' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 5, + "start_line": 2 + } + }, + "840": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/5c2b7aeab167481680df60350af517363d2959feb2d8d22d44792fc66abecaed.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 23, + "start_line": 4 + } + }, + "842": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/5c2b7aeab167481680df60350af517363d2959feb2d8d22d44792fc66abecaed.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 19, + "start_line": 5 + } + }, + "843": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/5c2b7aeab167481680df60350af517363d2959feb2d8d22d44792fc66abecaed.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 14, + "start_line": 6 + }, + "While expanding the reference 'calldata_ptr_start' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 12, + "start_line": 3 + } + }, + "844": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/5c2b7aeab167481680df60350af517363d2959feb2d8d22d44792fc66abecaed.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 2 + } + }, + "846": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/76d47b6ecb46e7f4250b26887706f0f04aa2361d0143dad18e4d95f1bc581c2f.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/f3ca6393e0af20d9fe61c47a8d578ee2acd5b76d851afe770ee26235f964e8a6.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/b0dcc1491822147bd0ab1828bd650b5232e20e602d6427c1cb6b4ec241a9cdb5.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling return values of" + ], + "start_col": 23, + "start_line": 1 + }, + "While expanding the reference '__return_value_actual_size' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling return values of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__return_value_ptr' in:" + ], + "start_col": 28, + "start_line": 5 + }, + "While handling return value 'res'" + ], + "start_col": 26, + "start_line": 2 + } + }, + "848": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/b0dcc1491822147bd0ab1828bd650b5232e20e602d6427c1cb6b4ec241a9cdb5.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling return values of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "849": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 84, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/5c2b7aeab167481680df60350af517363d2959feb2d8d22d44792fc66abecaed.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/9a82246979d7b39f8f6ee8d4abee119d90648cb59b4c077f4d91669844f6695c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 2 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 84 + } + }, + "850": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/9a82246979d7b39f8f6ee8d4abee119d90648cb59b4c077f4d91669844f6695c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 52, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 52, + "start_line": 1 + } + }, + "851": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/76d47b6ecb46e7f4250b26887706f0f04aa2361d0143dad18e4d95f1bc581c2f.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/9a82246979d7b39f8f6ee8d4abee119d90648cb59b4c077f4d91669844f6695c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 13, + "start_line": 2 + }, + "While expanding the reference '__return_value_arg_res' in:" + ], + "start_col": 28, + "start_line": 5 + }, + "While handling return value 'res'" + ], + "start_col": 30, + "start_line": 1 + } + }, + "852": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/9a82246979d7b39f8f6ee8d4abee119d90648cb59b4c077f4d91669844f6695c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "853": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "855": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 42, + "start_line": 3 + } + }, + "857": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 6, + "start_line": 3 + } + }, + "858": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 21, + "start_line": 7 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "859": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 45, + "start_line": 7 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 2 + } + }, + "860": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 45, + "start_line": 7 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 5 + } + }, + "862": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 45, + "start_line": 7 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 32, + "start_line": 10 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 21, + "start_line": 7 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "864": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 45, + "start_line": 7 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 10 + } + }, + "865": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 45, + "start_line": 7 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 12 + }, + "While expanding the reference '__calldata_ptr_copy' in:" + ], + "start_col": 45, + "start_line": 7 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 27, + "start_line": 7 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 21, + "start_line": 7 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "867": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 45, + "start_line": 7 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 13 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 45, + "start_line": 7 + } + }, + "868": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 45, + "start_line": 7 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 14 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 21, + "start_line": 7 + } + }, + "869": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 29, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 45, + "start_line": 7 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 11 + } + }, + "871": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/9d9536b18a319f36eeef57c36e532f983f44265fc7e39581e2aa4bf1393efc61.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 84, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/8c886c1d349f82bd591f8eec585855ee3491fc3ebec5aa6c756bbdba7906357e.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 84 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 30, + "start_line": 1 + } + }, + "872": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/9d9536b18a319f36eeef57c36e532f983f44265fc7e39581e2aa4bf1393efc61.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/8c886c1d349f82bd591f8eec585855ee3491fc3ebec5aa6c756bbdba7906357e.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 16, + "start_line": 3 + }, + "While expanding the reference 'class_hash' in:" + ], + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 5, + "start_line": 2 + } + }, + "873": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/8c886c1d349f82bd591f8eec585855ee3491fc3ebec5aa6c756bbdba7906357e.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 23, + "start_line": 4 + } + }, + "875": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/8c886c1d349f82bd591f8eec585855ee3491fc3ebec5aa6c756bbdba7906357e.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 19, + "start_line": 5 + } + }, + "876": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/8c886c1d349f82bd591f8eec585855ee3491fc3ebec5aa6c756bbdba7906357e.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 14, + "start_line": 6 + }, + "While expanding the reference 'calldata_ptr_start' in:" + ], + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 12, + "start_line": 3 + } + }, + "877": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/8c886c1d349f82bd591f8eec585855ee3491fc3ebec5aa6c756bbdba7906357e.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 2 + } + }, + "879": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 84, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/8c886c1d349f82bd591f8eec585855ee3491fc3ebec5aa6c756bbdba7906357e.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/9d9536b18a319f36eeef57c36e532f983f44265fc7e39581e2aa4bf1393efc61.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/f50361dd9bfac65181c540d35f212e1c4d9a5552b713bad47868a2b80022ed2a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 30, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 2 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 84 + } + }, + "880": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/9d9536b18a319f36eeef57c36e532f983f44265fc7e39581e2aa4bf1393efc61.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/f50361dd9bfac65181c540d35f212e1c4d9a5552b713bad47868a2b80022ed2a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 51, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 45, + "start_line": 7 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 7, + "start_line": 5 + } + }, + "881": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/f50361dd9bfac65181c540d35f212e1c4d9a5552b713bad47868a2b80022ed2a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "882": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "884": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 42, + "start_line": 3 + } + }, + "886": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 6, + "start_line": 3 + } + }, + "887": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 25, + "start_line": 13 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "888": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 49, + "start_line": 13 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 2 + } + }, + "889": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 49, + "start_line": 13 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 5 + } + }, + "891": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 49, + "start_line": 13 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 32, + "start_line": 10 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 25, + "start_line": 13 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "893": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 49, + "start_line": 13 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 10 + } + }, + "894": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 49, + "start_line": 13 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 12 + }, + "While expanding the reference '__calldata_ptr_copy' in:" + ], + "start_col": 49, + "start_line": 13 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 27, + "start_line": 7 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 25, + "start_line": 13 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "896": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 49, + "start_line": 13 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 13 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 49, + "start_line": 13 + } + }, + "897": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 49, + "start_line": 13 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 14 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 25, + "start_line": 13 + } + }, + "898": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 29, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 49, + "start_line": 13 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 11 + } + }, + "900": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1b43ef6b4af8e72427aa5dbe8c8bae252da7027ca95f7e3d957ba8a9c97db773.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 84, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1ea6a15d153eb82ed57fee60e4a7212a1ca02205c458f23f0d80d5a00c7427e3.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 84 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 34, + "start_line": 1 + } + }, + "901": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1b43ef6b4af8e72427aa5dbe8c8bae252da7027ca95f7e3d957ba8a9c97db773.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1ea6a15d153eb82ed57fee60e4a7212a1ca02205c458f23f0d80d5a00c7427e3.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 16, + "start_line": 3 + }, + "While expanding the reference 'class_hash' in:" + ], + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 5, + "start_line": 2 + } + }, + "902": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1ea6a15d153eb82ed57fee60e4a7212a1ca02205c458f23f0d80d5a00c7427e3.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 23, + "start_line": 4 + } + }, + "904": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1ea6a15d153eb82ed57fee60e4a7212a1ca02205c458f23f0d80d5a00c7427e3.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 19, + "start_line": 5 + } + }, + "905": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/3b692dedd2c44d2387603d103150d54c4d1a08ee33e54b3bbc47f00a2a3641d1.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1ea6a15d153eb82ed57fee60e4a7212a1ca02205c458f23f0d80d5a00c7427e3.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 14, + "start_line": 6 + }, + "While expanding the reference 'calldata_ptr_start' in:" + ], + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 12, + "start_line": 3 + } + }, + "906": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1ea6a15d153eb82ed57fee60e4a7212a1ca02205c458f23f0d80d5a00c7427e3.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 2 + } + }, + "908": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 84, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 6, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1ea6a15d153eb82ed57fee60e4a7212a1ca02205c458f23f0d80d5a00c7427e3.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1b43ef6b4af8e72427aa5dbe8c8bae252da7027ca95f7e3d957ba8a9c97db773.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/f50361dd9bfac65181c540d35f212e1c4d9a5552b713bad47868a2b80022ed2a.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 2 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 84 + } + }, + "909": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 60, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1b43ef6b4af8e72427aa5dbe8c8bae252da7027ca95f7e3d957ba8a9c97db773.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/f50361dd9bfac65181c540d35f212e1c4d9a5552b713bad47868a2b80022ed2a.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 55, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 49, + "start_line": 13 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 7, + "start_line": 5 + } + }, + "910": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/f50361dd9bfac65181c540d35f212e1c4d9a5552b713bad47868a2b80022ed2a.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "911": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "912": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "913": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 94, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 21, + "start_line": 9 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 19, + "start_line": 8 + } + }, + "915": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + } + }, + "916": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 30, + "start_line": 15 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 12 + } + }, + "917": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 30, + "start_line": 15 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 12 + } + }, + "918": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 30, + "start_line": 15 + } + }, + "920": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 37, + "start_line": 16 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 12 + } + }, + "921": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 58, + "start_line": 16 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 15 + } + }, + "922": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 37, + "start_line": 16 + } + }, + "924": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 31, + "start_line": 18 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 37, + "start_line": 16 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + } + }, + "925": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 32, + "start_line": 19 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 15 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "926": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 15, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 20, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 35, + "start_line": 20 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 15 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "927": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 46, + "start_line": 21 + }, + "While expanding the reference '__storage_var_temp0' in:" + ], + "start_col": 14, + "start_line": 16 + } + }, + "928": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 22, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 9, + "start_line": 22 + } + }, + "929": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 30, + "start_line": 26 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 25 + } + }, + "930": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 30, + "start_line": 26 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 25 + } + }, + "931": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 30, + "start_line": 26 + } + }, + "933": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 364, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 9, + "start_line": 27 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 364 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 25 + } + }, + "934": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 31, + "start_line": 27 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 26 + } + }, + "935": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 55, + "start_line": 27 + } + }, + "936": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 9, + "start_line": 27 + } + }, + "938": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 28, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 9, + "start_line": 28 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 26 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "939": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 28, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 9, + "start_line": 28 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 26 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "940": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 28, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/impl.cairo" + }, + "start_col": 9, + "start_line": 28 + } + }, + "941": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 36, + "start_line": 9 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "942": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 94, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 50, + "start_line": 9 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 19, + "start_line": 8 + } + }, + "944": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 55, + "start_line": 9 + } + }, + "945": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 21, + "start_line": 9 + } + }, + "947": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 21, + "start_line": 10 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 12 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "948": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 44, + "start_line": 10 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 14, + "start_line": 9 + } + }, + "949": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 21, + "start_line": 10 + } + }, + "951": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 9, + "start_line": 11 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 9 + } + }, + "952": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/storage.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 9, + "start_line": 11 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 21, + "start_line": 10 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 24, + "start_line": 12 + } + }, + "953": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 21, + "start_line": 11 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 14, + "start_line": 10 + } + }, + "954": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 9, + "start_line": 11 + } + }, + "955": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 30, + "start_line": 17 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 14 + } + }, + "956": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 30, + "start_line": 17 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 14 + } + }, + "957": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 92, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 35, + "start_line": 17 + }, + "While expanding the reference 'key' in:" + ], + "start_col": 82, + "start_line": 14 + } + }, + "958": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 30, + "start_line": 17 + } + }, + "960": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 37, + "start_line": 18 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 14 + } + }, + "961": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 58, + "start_line": 18 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 17 + } + }, + "962": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 37, + "start_line": 18 + } + }, + "964": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 20, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 31, + "start_line": 20 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 37, + "start_line": 18 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + } + }, + "965": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 32, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 17 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "966": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 22, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 35, + "start_line": 22 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 17 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "967": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 46, + "start_line": 23 + }, + "While expanding the reference '__storage_var_temp0' in:" + ], + "start_col": 14, + "start_line": 18 + } + }, + "968": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 9, + "start_line": 24 + } + }, + "969": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 30, + "start_line": 30 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 27 + } + }, + "970": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 30, + "start_line": 30 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 27 + } + }, + "971": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 28, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 35, + "start_line": 30 + }, + "While expanding the reference 'key' in:" + ], + "start_col": 9, + "start_line": 28 + } + }, + "972": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 30, + "start_line": 30 + } + }, + "974": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 27, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 364, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 9, + "start_line": 31 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 364 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 27 + } + }, + "975": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 31, + "start_line": 31 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 30 + } + }, + "976": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 55, + "start_line": 31 + } + }, + "977": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 31, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 9, + "start_line": 31 + } + }, + "979": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 9, + "start_line": 32 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 30 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "980": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 30, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 9, + "start_line": 32 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 30 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "981": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 32, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/impl.cairo" + }, + "start_col": 9, + "start_line": 32 + } + }, + "982": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "983": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "984": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 94, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 21, + "start_line": 9 + }, + "While expanding the reference 'res' in:" + ], + "start_col": 19, + "start_line": 8 + } + }, + "986": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 9, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 9, + "start_line": 9 + } + }, + "987": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 30, + "start_line": 13 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 12 + } + }, + "988": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 30, + "start_line": 13 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 12 + } + }, + "989": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 30, + "start_line": 13 + } + }, + "991": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 37, + "start_line": 14 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 12 + } + }, + "992": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 58, + "start_line": 14 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 13 + } + }, + "993": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 37, + "start_line": 14 + } + }, + "995": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 346, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 16, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 31, + "start_line": 16 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 37, + "start_line": 14 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 346 + } + }, + "996": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 17, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 32, + "start_line": 17 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 13 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "997": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 18, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 35, + "start_line": 18 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 13 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "998": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 46, + "start_line": 19 + }, + "While expanding the reference '__storage_var_temp0' in:" + ], + "start_col": 14, + "start_line": 14 + } + }, + "999": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 20, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 9, + "start_line": 20 + } + }, + "1000": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 30, + "start_line": 24 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 23 + } + }, + "1001": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 30, + "start_line": 24 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 23 + } + }, + "1002": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 30, + "start_line": 24 + } + }, + "1004": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 23, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 364, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 9, + "start_line": 25 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 364 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 23 + } + }, + "1005": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 43, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 31, + "start_line": 25 + }, + "While expanding the reference 'storage_addr' in:" + ], + "start_col": 14, + "start_line": 24 + } + }, + "1006": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 79, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 55, + "start_line": 25 + } + }, + "1007": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 25, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 9, + "start_line": 25 + } + }, + "1009": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 9, + "start_line": 26 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 19 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 24 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 15, + "start_line": 7 + } + }, + "1010": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 24, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 19, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 9, + "start_line": 26 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 19 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 24 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 44, + "start_line": 7 + } + }, + "1011": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 26, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/impl.cairo" + }, + "start_col": 9, + "start_line": 26 + } + }, + "1012": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1014": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 2 + } + }, + "1016": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "1017": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 23, + "start_line": 3 + } + }, + "1019": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "1020": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 4 + } + }, + "1022": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 4 + } + }, + "1023": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/66ce5052d98668fd8687fa8fb10ac402eee7cf7e1ac14c755b464fade89c3881.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 35, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 35 + }, + "While handling calldata argument 'implementation_hash'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1024": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/928e8ea0335478f7ee270fc274a2081a0cb7a059bbc6b82d44867e997798c8fb.cairo" + }, + "parent_location": [ + { + "end_col": 13, + "end_line": 36, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 36 + }, + "While handling calldata argument 'eic_hash'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1025": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 37 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1026": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 38 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1027": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 38 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 5 + } + }, + "1029": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 38 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 32, + "start_line": 10 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 37 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1031": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 38 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 10 + } + }, + "1032": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 38 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 12 + }, + "While expanding the reference '__calldata_ptr_copy' in:" + ], + "start_col": 5, + "start_line": 38 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 27, + "start_line": 7 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 37 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1034": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 38 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 13 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 38 + } + }, + "1035": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 38 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 14 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 37 + } + }, + "1036": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 29, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 38 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 11 + } + }, + "1038": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/7174b24f581d23f70bd4d8ce2ea0c2b36ec7a7f140792036ec3116d51ba04a0c.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 39, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 39 + }, + "While handling calldata argument 'final'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1039": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/7174b24f581d23f70bd4d8ce2ea0c2b36ec7a7f140792036ec3116d51ba04a0c.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 39, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 39 + }, + "While handling calldata argument 'final'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1041": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 383, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 383 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "1042": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 21, + "start_line": 1 + } + }, + "1044": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 29, + "start_line": 1 + }, + "While expanding the reference '__keys_ptr' in:" + ], + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 2 + } + }, + "1045": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + } + }, + "1046": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 94, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 84, + "start_line": 1 + }, + "While expanding the reference '__data_ptr' in:" + ], + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 4 + } + }, + "1047": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1049": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 38, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 38 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 7, + "start_line": 5 + } + }, + "1050": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1051": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1053": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 2 + } + }, + "1055": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "1056": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 23, + "start_line": 3 + } + }, + "1058": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "1059": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 4 + } + }, + "1061": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 4 + } + }, + "1062": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/66ce5052d98668fd8687fa8fb10ac402eee7cf7e1ac14c755b464fade89c3881.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 46, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 46 + }, + "While handling calldata argument 'implementation_hash'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1063": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/928e8ea0335478f7ee270fc274a2081a0cb7a059bbc6b82d44867e997798c8fb.cairo" + }, + "parent_location": [ + { + "end_col": 13, + "end_line": 47, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 47 + }, + "While handling calldata argument 'eic_hash'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1064": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 48, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 48 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1065": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 49 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1066": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 49 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 5 + } + }, + "1068": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 48, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 49 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 32, + "start_line": 10 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 48 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1070": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 49 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 10 + } + }, + "1071": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 48, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 49 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 12 + }, + "While expanding the reference '__calldata_ptr_copy' in:" + ], + "start_col": 5, + "start_line": 49 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 27, + "start_line": 7 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 48 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1073": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 49 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 13 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 49 + } + }, + "1074": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 48, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 49 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 14 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 48 + } + }, + "1075": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 29, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 49 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 11 + } + }, + "1077": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/7174b24f581d23f70bd4d8ce2ea0c2b36ec7a7f140792036ec3116d51ba04a0c.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 50 + }, + "While handling calldata argument 'final'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1078": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/7174b24f581d23f70bd4d8ce2ea0c2b36ec7a7f140792036ec3116d51ba04a0c.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 50 + }, + "While handling calldata argument 'final'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1080": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 383, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 383 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "1081": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 21, + "start_line": 1 + } + }, + "1083": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 29, + "start_line": 1 + }, + "While expanding the reference '__keys_ptr' in:" + ], + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 2 + } + }, + "1084": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + } + }, + "1085": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 94, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 84, + "start_line": 1 + }, + "While expanding the reference '__data_ptr' in:" + ], + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 4 + } + }, + "1086": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1088": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 49, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 49 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 7, + "start_line": 5 + } + }, + "1089": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1090": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1092": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 2 + } + }, + "1094": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "1095": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 23, + "start_line": 3 + } + }, + "1097": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "1098": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 4 + } + }, + "1100": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 4 + } + }, + "1101": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/66ce5052d98668fd8687fa8fb10ac402eee7cf7e1ac14c755b464fade89c3881.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 57 + }, + "While handling calldata argument 'implementation_hash'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1102": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/928e8ea0335478f7ee270fc274a2081a0cb7a059bbc6b82d44867e997798c8fb.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 33, + "start_line": 57 + }, + "While handling calldata argument 'eic_hash'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1103": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 50, + "start_line": 57 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1104": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 74, + "start_line": 57 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1105": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 74, + "start_line": 57 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 5 + } + }, + "1107": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 46, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 74, + "start_line": 57 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 32, + "start_line": 10 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 50, + "start_line": 57 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1109": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 74, + "start_line": 57 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 10 + } + }, + "1110": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/38c72c50f1665a213efa650d7f68cef7eaf0958eced869130656bea887f65d11.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 7, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 74, + "start_line": 57 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 12 + }, + "While expanding the reference '__calldata_ptr_copy' in:" + ], + "start_col": 74, + "start_line": 57 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 27, + "start_line": 7 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 50, + "start_line": 57 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1112": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 93, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 74, + "start_line": 57 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 13 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 74, + "start_line": 57 + } + }, + "1113": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 72, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 74, + "start_line": 57 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 14 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 50, + "start_line": 57 + } + }, + "1114": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 29, + "end_line": 14, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 74, + "start_line": 57 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 11 + } + }, + "1116": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 383, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 383 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "1117": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 21, + "start_line": 1 + } + }, + "1119": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 29, + "start_line": 1 + }, + "While expanding the reference '__keys_ptr' in:" + ], + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 2 + } + }, + "1120": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + } + }, + "1121": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 94, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 84, + "start_line": 1 + }, + "While expanding the reference '__data_ptr' in:" + ], + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 4 + } + }, + "1122": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1124": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/fa46be02e6afd518e6fd13081889c66457b109d5dfc1a6bae386525c1c510164.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 74, + "start_line": 57 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 7, + "start_line": 5 + } + }, + "1125": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1126": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 13, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1128": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 2 + } + }, + "1130": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "1131": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 23, + "start_line": 3 + } + }, + "1133": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "1134": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 34, + "start_line": 4 + } + }, + "1136": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 6, + "start_line": 4 + } + }, + "1137": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/66ce5052d98668fd8687fa8fb10ac402eee7cf7e1ac14c755b464fade89c3881.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 31, + "start_line": 63 + }, + "While handling calldata argument 'implementation_hash'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1138": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/66ce5052d98668fd8687fa8fb10ac402eee7cf7e1ac14c755b464fade89c3881.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 31, + "start_line": 63 + }, + "While handling calldata argument 'implementation_hash'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1140": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 383, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 383 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "1141": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 21, + "start_line": 1 + } + }, + "1143": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 29, + "start_line": 1 + }, + "While expanding the reference '__keys_ptr' in:" + ], + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 2 + } + }, + "1144": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 50, + "start_line": 1 + } + }, + "1145": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 22, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/65c5085194e774f24b349fa5ca17d70e9ee7479a2b72fa6bed01a6505af19ff9.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 94, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 84, + "start_line": 1 + }, + "While expanding the reference '__data_ptr' in:" + ], + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 12, + "start_line": 4 + } + }, + "1146": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1148": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "1149": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/858f2c0e8fdda3108b2e383053abb5bae67b6b5a2bf306a848bd20c7d5507d8c.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1150": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 70, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 34, + "start_line": 70 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "1151": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 70, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 34, + "start_line": 70 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + } + }, + "1152": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 86, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/class_hash/decl.cairo" + }, + "parent_location": [ + { + "end_col": 51, + "end_line": 70, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 34, + "start_line": 70 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 67 + } + }, + "1153": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 70, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 34, + "start_line": 70 + } + }, + "1155": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 71, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 71 + } + }, + "1156": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_encode_return" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/return/implementation/76277dac574af7bf0c2e447a5ae96652d6a6e738957009ad46f922f0ef5d185a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 3 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 17, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/return/implementation/76277dac574af7bf0c2e447a5ae96652d6a6e738957009ad46f922f0ef5d185a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 4 + } + }, + "1158": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/d59c7dc669755d681093c87b3bcf4ac40da1fc4527d813dea68f0ecbc81f1e73.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 68 + }, + "While handling return value 'implementation_hash_'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1159": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/d59c7dc669755d681093c87b3bcf4ac40da1fc4527d813dea68f0ecbc81f1e73.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 68, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/external/return/implementation/76277dac574af7bf0c2e447a5ae96652d6a6e738957009ad46f922f0ef5d185a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While handling return value of" + ], + "start_col": 18, + "start_line": 11 + }, + "While expanding the reference '__return_value_ptr' in:" + ], + "start_col": 5, + "start_line": 68 + }, + "While handling return value 'implementation_hash_'" + ], + "start_col": 26, + "start_line": 2 + } + }, + "1161": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 93, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/return/implementation/76277dac574af7bf0c2e447a5ae96652d6a6e738957009ad46f922f0ef5d185a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/external/return/implementation/76277dac574af7bf0c2e447a5ae96652d6a6e738957009ad46f922f0ef5d185a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While handling return value of" + ], + "start_col": 25, + "start_line": 10 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 67 + }, + "While handling return value of" + ], + "start_col": 78, + "start_line": 1 + } + }, + "1162": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/external/return/implementation/76277dac574af7bf0c2e447a5ae96652d6a6e738957009ad46f922f0ef5d185a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While handling return value of" + ], + "start_col": 18, + "start_line": 11 + } + }, + "1163": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/external/return/implementation/76277dac574af7bf0c2e447a5ae96652d6a6e738957009ad46f922f0ef5d185a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/external/return/implementation/76277dac574af7bf0c2e447a5ae96652d6a6e738957009ad46f922f0ef5d185a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While handling return value of" + ], + "start_col": 14, + "start_line": 12 + }, + "While expanding the reference '__return_value_ptr_start' in:" + ], + "start_col": 6, + "start_line": 67 + }, + "While handling return value of" + ], + "start_col": 11, + "start_line": 5 + } + }, + "1164": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/external/return/implementation/76277dac574af7bf0c2e447a5ae96652d6a6e738957009ad46f922f0ef5d185a.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 9 + } + }, + "1165": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1166": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "1167": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "1168": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 86, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1169": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + } + }, + "1171": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 103, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 88, + "start_line": 2 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "1172": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 104, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 48, + "start_line": 2 + } + }, + "1174": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "1175": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "1176": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "1177": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 2 + } + }, + "1178": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/implementation/50ada6d371d4edef20052d698949a56e1715536a3e54be1891e2de7ebcd77040.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 37, + "start_line": 2 + } + }, + "1179": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 67 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1180": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 74, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 273, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 84, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 82 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 20, + "start_line": 273 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 47, + "start_line": 75 + } + }, + "1181": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 76, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 83, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 83 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 76 + } + }, + "1182": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 77, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 83, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 31, + "start_line": 83 + }, + "While expanding the reference 'eic_hash' in:" + ], + "start_col": 5, + "start_line": 77 + } + }, + "1183": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 78, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 83, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 41, + "start_line": 83 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 78 + } + }, + "1184": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 79, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 83, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 58, + "start_line": 83 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 79 + } + }, + "1185": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 80, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 83, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 71, + "start_line": 83 + }, + "While expanding the reference 'final' in:" + ], + "start_col": 5, + "start_line": 80 + } + }, + "1186": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 84, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 82 + } + }, + "1188": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 85 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 75 + } + }, + "1189": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 273, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 84, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 85 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 32, + "start_line": 82 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 20, + "start_line": 273 + } + }, + "1190": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 91, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 85 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 76, + "start_line": 75 + } + }, + "1191": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 82, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 44, + "start_line": 85 + }, + "While expanding the reference 'implementation_key' in:" + ], + "start_col": 10, + "start_line": 82 + } + }, + "1192": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 85, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 85 + } + }, + "1194": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 86, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 86 + } + }, + "1195": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time_encode_return" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/return/implementation_time/58056490058fccf98a30c1e808265651b36def4ea1622f0fb9743e72cfaeb35e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 3 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 17, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/return/implementation_time/58056490058fccf98a30c1e808265651b36def4ea1622f0fb9743e72cfaeb35e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 4 + } + }, + "1197": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/86dea33f8d6357e54eedfd8e6e4056320a7cdfd419ce0c0410a0b9a23a277d25.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 81, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 7, + "start_line": 81 + }, + "While handling return value 'time'" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1198": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/86dea33f8d6357e54eedfd8e6e4056320a7cdfd419ce0c0410a0b9a23a277d25.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 81, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/external/return/implementation_time/58056490058fccf98a30c1e808265651b36def4ea1622f0fb9743e72cfaeb35e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While handling return value of" + ], + "start_col": 18, + "start_line": 11 + }, + "While expanding the reference '__return_value_ptr' in:" + ], + "start_col": 7, + "start_line": 81 + }, + "While handling return value 'time'" + ], + "start_col": 26, + "start_line": 2 + } + }, + "1200": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/return/implementation_time/58056490058fccf98a30c1e808265651b36def4ea1622f0fb9743e72cfaeb35e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 10, + "input_file": { + "filename": "autogen/starknet/external/return/implementation_time/58056490058fccf98a30c1e808265651b36def4ea1622f0fb9743e72cfaeb35e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While handling return value of" + ], + "start_col": 25, + "start_line": 10 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 75 + }, + "While handling return value of" + ], + "start_col": 67, + "start_line": 1 + } + }, + "1201": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 11, + "input_file": { + "filename": "autogen/starknet/external/return/implementation_time/58056490058fccf98a30c1e808265651b36def4ea1622f0fb9743e72cfaeb35e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While handling return value of" + ], + "start_col": 18, + "start_line": 11 + } + }, + "1202": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/external/return/implementation_time/58056490058fccf98a30c1e808265651b36def4ea1622f0fb9743e72cfaeb35e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/external/return/implementation_time/58056490058fccf98a30c1e808265651b36def4ea1622f0fb9743e72cfaeb35e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While handling return value of" + ], + "start_col": 14, + "start_line": 12 + }, + "While expanding the reference '__return_value_ptr_start' in:" + ], + "start_col": 6, + "start_line": 75 + }, + "While handling return value of" + ], + "start_col": 11, + "start_line": 5 + } + }, + "1203": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time_encode_return" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 12, + "input_file": { + "filename": "autogen/starknet/external/return/implementation_time/58056490058fccf98a30c1e808265651b36def4ea1622f0fb9743e72cfaeb35e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While handling return value of" + ], + "start_col": 5, + "start_line": 9 + } + }, + "1204": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 91, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 79, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 79 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 2 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 76, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1205": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 78, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 79, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 79 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 28, + "start_line": 2 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 78 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1206": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 79, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 79 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1207": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 78, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 79, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 79 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 26, + "start_line": 8 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 78 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1209": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 78, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 79, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 79 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 43, + "start_line": 8 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 78 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1210": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 79, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 79 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 26, + "start_line": 8 + } + }, + "1211": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/7e43e5183ee46e00aab342ce0cb4c926a655274ff7f4f0d65a657711fbffdc3d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 80, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/5e1cc73f0b484f90bb02da164d88332b40c6f698801aa4d3c603dab22157e902.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While handling calldata of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__calldata_actual_size' in:" + ], + "start_col": 6, + "start_line": 75 + }, + "While handling calldata of" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 80 + }, + "While handling calldata argument 'final'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1213": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1214": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 91, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 79, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 79 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 23, + "start_line": 3 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 76, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1215": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "1216": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 74, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 47, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "1217": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 79, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 79 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 23, + "start_line": 3 + } + }, + "1219": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/d2ee302a18234bed9fbd456e6c41abd6fb5413110dcab9643a9c66e4b29a240a.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 76, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 173, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 138, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 76 + }, + "While handling calldata argument 'implementation_hash_'" + ], + "start_col": 43, + "start_line": 1 + } + }, + "1220": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/eea8394a33414521e4ece8855a00f085f6843a8b97cef2bfb099279dfce7f148.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 77, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 207, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 184, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_eic_hash' in:" + ], + "start_col": 5, + "start_line": 77 + }, + "While handling calldata argument 'eic_hash'" + ], + "start_col": 31, + "start_line": 1 + } + }, + "1221": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 78, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 255, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 225, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 78 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1222": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 79, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 295, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 269, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_init_vector' in:" + ], + "start_col": 5, + "start_line": 79 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 34, + "start_line": 5 + } + }, + "1224": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/7e43e5183ee46e00aab342ce0cb4c926a655274ff7f4f0d65a657711fbffdc3d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 80, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 323, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 303, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_final' in:" + ], + "start_col": 5, + "start_line": 80 + }, + "While handling calldata argument 'final'" + ], + "start_col": 28, + "start_line": 1 + } + }, + "1225": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + } + }, + "1227": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 108, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 93, + "start_line": 2 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "1228": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 109, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 48, + "start_line": 2 + } + }, + "1230": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "1231": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "1232": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 6, + "start_line": 2 + } + }, + "1233": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 2 + } + }, + "1234": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/82ad15990a17f21c6727e53b67cf046e189c7c8df651444d44c75a08c08583c3.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 37, + "start_line": 2 + } + }, + "1235": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/implementation_time/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 25, + "end_line": 75, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 75 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1236": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 97, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 97 + } + }, + "1238": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 98 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 90 + } + }, + "1239": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 98 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 90 + } + }, + "1240": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 90, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 98 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 90 + } + }, + "1241": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 98 + } + }, + "1243": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 91, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 102, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 25, + "start_line": 102 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 91 + } + }, + "1244": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 102, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 102 + } + }, + "1246": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 292, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 105, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 105 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 292 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 98 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + } + }, + "1247": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 105, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 105 + } + }, + "1249": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 105, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 105, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 10, + "start_line": 105 + }, + "While auto generating local variable for 'now_'." + ], + "start_col": 10, + "start_line": 105 + } + }, + "1250": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 292, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 105, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 30, + "start_line": 106 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 105 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 292 + } + }, + "1251": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 30, + "start_line": 106 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 98 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + } + }, + "1252": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 98, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 30, + "start_line": 106 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 98 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + } + }, + "1253": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 30, + "start_line": 106 + } + }, + "1255": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 26, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 10, + "start_line": 106 + }, + "While auto generating local variable for 'upgrade_timelock'." + ], + "start_col": 10, + "start_line": 106 + } + }, + "1256": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 30, + "start_line": 106 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While auto generating local variable for 'syscall_ptr'." + ], + "start_col": 30, + "start_line": 106 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + } + }, + "1257": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 30, + "start_line": 106 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While auto generating local variable for 'range_check_ptr'." + ], + "start_col": 30, + "start_line": 106 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + } + }, + "1258": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 273, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 109, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 107 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 20, + "start_line": 273 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 30, + "start_line": 106 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + } + }, + "1259": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 91, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 108, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 108 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 91 + } + }, + "1260": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 108, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 31, + "start_line": 108 + }, + "While expanding the reference 'eic_hash' in:" + ], + "start_col": 5, + "start_line": 92 + } + }, + "1261": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 108, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 41, + "start_line": 108 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 93 + } + }, + "1262": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 108, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 58, + "start_line": 108 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 94 + } + }, + "1263": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 95, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 108, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 71, + "start_line": 108 + }, + "While expanding the reference 'final' in:" + ], + "start_col": 5, + "start_line": 95 + } + }, + "1264": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 109, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 107 + } + }, + "1266": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 110 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 30, + "start_line": 106 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While auto generating local variable for 'syscall_ptr'." + ], + "start_col": 30, + "start_line": 106 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + } + }, + "1267": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 273, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 109, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 110 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 32, + "start_line": 107 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 20, + "start_line": 273 + } + }, + "1268": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 106, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 110 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 30, + "start_line": 106 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While auto generating local variable for 'range_check_ptr'." + ], + "start_col": 30, + "start_line": 106 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + } + }, + "1269": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 107, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 110 + }, + "While expanding the reference 'implementation_key' in:" + ], + "start_col": 10, + "start_line": 107 + } + }, + "1270": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 75, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 52, + "start_line": 110 + } + }, + "1271": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 110 + } + }, + "1273": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 110 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 5, + "start_line": 110 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + } + }, + "1274": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 118, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 112 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 110 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + } + }, + "1275": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 118, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 112 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 110 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + } + }, + "1276": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 91, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 113, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 113 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 91 + } + }, + "1277": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 114, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 114 + }, + "While expanding the reference 'eic_hash' in:" + ], + "start_col": 5, + "start_line": 92 + } + }, + "1278": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 115, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 25, + "start_line": 115 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 93 + } + }, + "1279": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 116, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 21, + "start_line": 116 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 94 + } + }, + "1280": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 95, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 117, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 15, + "start_line": 117 + }, + "While expanding the reference 'final' in:" + ], + "start_col": 5, + "start_line": 95 + } + }, + "1281": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 118, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 112 + } + }, + "1283": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 118, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 119, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 119 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 90 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 112 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "1284": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 110, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 119, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 119 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 90 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 110 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 5, + "start_line": 110 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + } + }, + "1285": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_added/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 118, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 90, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 119, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 119 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 90 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 112 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 34 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "1286": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 119, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 119 + } + }, + "1287": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 90, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 94 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 2 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1288": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 94 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 28, + "start_line": 2 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 93 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1289": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 94 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1290": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 94 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 26, + "start_line": 8 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 93 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1292": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 94 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 43, + "start_line": 8 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 93 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1293": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 94 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 26, + "start_line": 8 + } + }, + "1294": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/7e43e5183ee46e00aab342ce0cb4c926a655274ff7f4f0d65a657711fbffdc3d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 95, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/5e1cc73f0b484f90bb02da164d88332b40c6f698801aa4d3c603dab22157e902.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While handling calldata of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__calldata_actual_size' in:" + ], + "start_col": 6, + "start_line": 90 + }, + "While handling calldata of" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 95 + }, + "While handling calldata argument 'final'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1296": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1297": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 90, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 94 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 23, + "start_line": 3 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1298": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "1299": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "1300": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 94 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 23, + "start_line": 3 + } + }, + "1302": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/d2ee302a18234bed9fbd456e6c41abd6fb5413110dcab9643a9c66e4b29a240a.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 91, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 173, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 138, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 91 + }, + "While handling calldata argument 'implementation_hash_'" + ], + "start_col": 43, + "start_line": 1 + } + }, + "1303": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/eea8394a33414521e4ece8855a00f085f6843a8b97cef2bfb099279dfce7f148.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 92, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 207, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 184, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_eic_hash' in:" + ], + "start_col": 5, + "start_line": 92 + }, + "While handling calldata argument 'eic_hash'" + ], + "start_col": 31, + "start_line": 1 + } + }, + "1304": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 93, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 255, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 225, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 93 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1305": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 94, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 295, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 269, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_init_vector' in:" + ], + "start_col": 5, + "start_line": 94 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 34, + "start_line": 5 + } + }, + "1307": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/7e43e5183ee46e00aab342ce0cb4c926a655274ff7f4f0d65a657711fbffdc3d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 95, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 323, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 303, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_final' in:" + ], + "start_col": 5, + "start_line": 95 + }, + "While handling calldata argument 'final'" + ], + "start_col": 28, + "start_line": 1 + } + }, + "1308": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + } + }, + "1310": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "1312": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "1313": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "1314": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "1315": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "1317": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "1318": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/add_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 90, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 90 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1319": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 130, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 130 + } + }, + "1321": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 131 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 28, + "start_line": 123 + } + }, + "1322": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 131 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 49, + "start_line": 123 + } + }, + "1323": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 93, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 131 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 78, + "start_line": 123 + } + }, + "1324": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 131 + } + }, + "1326": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 131 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + }, + "While auto generating local variable for 'syscall_ptr'." + ], + "start_col": 5, + "start_line": 131 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + } + }, + "1327": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 131 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + }, + "While auto generating local variable for 'range_check_ptr'." + ], + "start_col": 5, + "start_line": 131 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + } + }, + "1328": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 273, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 134, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 132 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 20, + "start_line": 273 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 131 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + } + }, + "1329": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 124, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 133 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 124 + } + }, + "1330": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 125, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 31, + "start_line": 133 + }, + "While expanding the reference 'eic_hash' in:" + ], + "start_col": 5, + "start_line": 125 + } + }, + "1331": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 41, + "start_line": 133 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 126 + } + }, + "1332": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 58, + "start_line": 133 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 127 + } + }, + "1333": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 128, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 133, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 71, + "start_line": 133 + }, + "While expanding the reference 'final' in:" + ], + "start_col": 5, + "start_line": 128 + } + }, + "1334": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 134, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 132 + } + }, + "1336": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 135 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 131 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + }, + "While auto generating local variable for 'syscall_ptr'." + ], + "start_col": 5, + "start_line": 131 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + } + }, + "1337": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 273, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 134, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 135 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 32, + "start_line": 132 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 20, + "start_line": 273 + } + }, + "1338": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 131, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 135 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 131 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + }, + "While auto generating local variable for 'range_check_ptr'." + ], + "start_col": 5, + "start_line": 131 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + } + }, + "1339": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 44, + "start_line": 135 + }, + "While expanding the reference 'implementation_key' in:" + ], + "start_col": 10, + "start_line": 132 + } + }, + "1340": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 135 + } + }, + "1342": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 138, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 138 + } + }, + "1344": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 139, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 139 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 28, + "start_line": 123 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 135 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + } + }, + "1345": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 139, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 139 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 49, + "start_line": 123 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 18, + "start_line": 135 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + } + }, + "1346": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 93, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 139, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 139 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 78, + "start_line": 123 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 18, + "start_line": 135 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + } + }, + "1347": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 139, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 139 + } + }, + "1348": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 142 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 135 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + } + }, + "1349": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 142 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 18, + "start_line": 135 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + } + }, + "1350": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 135, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 142 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 18, + "start_line": 135 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + } + }, + "1351": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 132, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 142 + }, + "While expanding the reference 'implementation_key' in:" + ], + "start_col": 10, + "start_line": 132 + } + }, + "1352": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 52, + "start_line": 142 + } + }, + "1354": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 142 + } + }, + "1356": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 142 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 5, + "start_line": 142 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + } + }, + "1357": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 149, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 143 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 142 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + } + }, + "1358": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 149, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 143 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 142 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + } + }, + "1359": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 124, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 144, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 144 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 124 + } + }, + "1360": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 125, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 145, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 145 + }, + "While expanding the reference 'eic_hash' in:" + ], + "start_col": 5, + "start_line": 125 + } + }, + "1361": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 146, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 25, + "start_line": 146 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 126 + } + }, + "1362": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 147, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 21, + "start_line": 147 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 127 + } + }, + "1363": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 128, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 15, + "start_line": 148 + }, + "While expanding the reference 'final' in:" + ], + "start_col": 5, + "start_line": 128 + } + }, + "1364": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 149, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 143 + } + }, + "1366": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 149, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 28, + "start_line": 123 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 143 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "1367": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 54, + "end_line": 142, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 49, + "start_line": 123 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 142 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 5, + "start_line": 142 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + } + }, + "1368": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_removed/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 28, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 149, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 93, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 150 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 78, + "start_line": 123 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 143 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 45 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "1369": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 150, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 150 + } + }, + "1370": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 93, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 127 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 2 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 78, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1371": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 127 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 28, + "start_line": 2 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 126 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1372": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 127 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1373": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 127 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 26, + "start_line": 8 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 126 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1375": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 127 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 43, + "start_line": 8 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 126 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1376": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 127 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 26, + "start_line": 8 + } + }, + "1377": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/7e43e5183ee46e00aab342ce0cb4c926a655274ff7f4f0d65a657711fbffdc3d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 128, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/5e1cc73f0b484f90bb02da164d88332b40c6f698801aa4d3c603dab22157e902.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While handling calldata of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__calldata_actual_size' in:" + ], + "start_col": 6, + "start_line": 123 + }, + "While handling calldata of" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 128 + }, + "While handling calldata argument 'final'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1379": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1380": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 93, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 127 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 23, + "start_line": 3 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 78, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1381": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 28, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "1382": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 49, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "1383": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 127 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 23, + "start_line": 3 + } + }, + "1385": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/d2ee302a18234bed9fbd456e6c41abd6fb5413110dcab9643a9c66e4b29a240a.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 124, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 173, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 138, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 124 + }, + "While handling calldata argument 'implementation_hash_'" + ], + "start_col": 43, + "start_line": 1 + } + }, + "1386": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/eea8394a33414521e4ece8855a00f085f6843a8b97cef2bfb099279dfce7f148.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 125, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 207, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 184, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_eic_hash' in:" + ], + "start_col": 5, + "start_line": 125 + }, + "While handling calldata argument 'eic_hash'" + ], + "start_col": 31, + "start_line": 1 + } + }, + "1387": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 126, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 255, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 225, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 126 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1388": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 127, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 295, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 269, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_init_vector' in:" + ], + "start_col": 5, + "start_line": 127 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 34, + "start_line": 5 + } + }, + "1390": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/7e43e5183ee46e00aab342ce0cb4c926a655274ff7f4f0d65a657711fbffdc3d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 128, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 323, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 303, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_final' in:" + ], + "start_col": 5, + "start_line": 128 + }, + "While handling calldata argument 'final'" + ], + "start_col": 28, + "start_line": 1 + } + }, + "1391": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + } + }, + "1393": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "1395": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "1396": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "1397": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "1398": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "1400": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "1401": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/remove_implementation/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 123, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 123 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1402": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 177, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 177 + } + }, + "1404": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 178, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 178 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 154 + } + }, + "1405": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 178, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 178 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 38, + "start_line": 154 + } + }, + "1406": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 178, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 178 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 67, + "start_line": 154 + } + }, + "1407": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 178, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 178 + } + }, + "1409": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 179, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 179 + } + }, + "1411": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 179, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 179, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 179 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 16 + }, + "While auto generating local variable for 'range_check_ptr'." + ], + "start_col": 5, + "start_line": 179 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 16 + } + }, + "1412": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 39, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 179, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 292, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 180, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 24, + "start_line": 180 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 292 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 179 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 16 + } + }, + "1413": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 180, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 24, + "start_line": 180 + } + }, + "1415": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 180, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 10, + "start_line": 180 + } + }, + "1416": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 292, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 180, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 292, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 180, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 24, + "start_line": 180 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 292 + }, + "While auto generating local variable for 'syscall_ptr'." + ], + "start_col": 24, + "start_line": 180 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 292 + } + }, + "1417": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 68, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 179, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 273, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 183, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 181 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 20, + "start_line": 273 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 179 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 16 + } + }, + "1418": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 155, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 182, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 182 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 155 + } + }, + "1419": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 156, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 182, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 31, + "start_line": 182 + }, + "While expanding the reference 'eic_hash' in:" + ], + "start_col": 5, + "start_line": 156 + } + }, + "1420": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 157, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 182, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 41, + "start_line": 182 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 157 + } + }, + "1421": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 182, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 58, + "start_line": 182 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 158 + } + }, + "1422": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 159, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 76, + "end_line": 182, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 71, + "start_line": 182 + }, + "While expanding the reference 'final' in:" + ], + "start_col": 5, + "start_line": 159 + } + }, + "1423": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 183, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 181 + } + }, + "1425": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 292, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 180, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 292, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 180, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 35, + "start_line": 184 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 24, + "start_line": 180 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 292 + }, + "While auto generating local variable for 'syscall_ptr'." + ], + "start_col": 24, + "start_line": 180 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 26, + "start_line": 292 + } + }, + "1426": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 273, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 183, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 35, + "start_line": 184 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 32, + "start_line": 181 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 20, + "start_line": 273 + } + }, + "1427": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 85, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 179, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 16, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 179, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 35, + "start_line": 184 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 179 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 16 + }, + "While auto generating local variable for 'range_check_ptr'." + ], + "start_col": 5, + "start_line": 179 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 16 + } + }, + "1428": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 181, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 61, + "start_line": 184 + }, + "While expanding the reference 'implementation_key' in:" + ], + "start_col": 10, + "start_line": 181 + } + }, + "1429": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 35, + "start_line": 184 + } + }, + "1431": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 10, + "start_line": 184 + } + }, + "1432": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 189, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 25, + "start_line": 189 + }, + "While expanding the reference 'activation_time' in:" + ], + "start_col": 16, + "start_line": 184 + } + }, + "1433": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 189, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 189 + } + }, + "1435": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 193 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 35, + "start_line": 184 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 13 + } + }, + "1436": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 193 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 35, + "start_line": 184 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 13 + } + }, + "1437": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 13, + "input_file": { + "filename": "autogen/starknet/storage_var/impl_activation_time/decl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 86, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 193 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 67 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 35, + "start_line": 184 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 13 + } + }, + "1438": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 193 + } + }, + "1440": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 10, + "start_line": 193 + } + }, + "1441": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 193 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + }, + "While auto generating local variable for 'syscall_ptr'." + ], + "start_col": 32, + "start_line": 193 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "1442": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 193 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 32, + "start_line": 193 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + } + }, + "1443": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 194, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 194 + } + }, + "1445": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 86, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 200, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 35, + "start_line": 200 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 32, + "start_line": 193 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 67 + } + }, + "1446": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 194, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 194 + } + }, + "1448": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 86, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 51, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/math.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 196, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 13, + "start_line": 196 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 16, + "start_line": 51 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 32, + "start_line": 193 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 67 + } + }, + "1449": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 31, + "end_line": 184, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 196, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 23, + "start_line": 196 + }, + "While expanding the reference 'activation_time' in:" + ], + "start_col": 16, + "start_line": 184 + } + }, + "1450": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 180, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 196, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 40, + "start_line": 196 + }, + "While expanding the reference 'now_' in:" + ], + "start_col": 16, + "start_line": 180 + } + }, + "1451": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 45, + "end_line": 196, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 13, + "start_line": 196 + } + }, + "1453": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 30, + "start_line": 265 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 32, + "start_line": 193 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + }, + "While auto generating local variable for 'syscall_ptr'." + ], + "start_col": 32, + "start_line": 193 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "1454": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 193, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 78, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 51, + "start_line": 265 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 32, + "start_line": 193 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 32, + "start_line": 193 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + } + }, + "1455": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 198, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 95, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 204 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 80, + "start_line": 265 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 17, + "start_line": 198 + } + }, + "1456": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 155, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 204 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 155 + } + }, + "1457": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 204 + } + }, + "1459": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 78, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 204 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 51, + "start_line": 265 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 5, + "start_line": 204 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 51, + "start_line": 265 + } + }, + "1460": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 212, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 207 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 204 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 30, + "start_line": 265 + } + }, + "1461": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 212, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 207 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 204 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 80, + "start_line": 265 + } + }, + "1462": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 155, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 208, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 208 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 155 + } + }, + "1463": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 156, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 209, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 18, + "start_line": 209 + }, + "While expanding the reference 'eic_hash' in:" + ], + "start_col": 5, + "start_line": 156 + } + }, + "1464": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 157, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 210, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 25, + "start_line": 210 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 157 + } + }, + "1465": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 211, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 21, + "start_line": 211 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 158 + } + }, + "1466": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 212, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 207 + } + }, + "1468": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 212, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 213 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 253 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 207 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "1469": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 78, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 204, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 213 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 204 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 51, + "start_line": 265 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 5, + "start_line": 204 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 51, + "start_line": 265 + } + }, + "1470": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_upgraded/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 29, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 212, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 90, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 213 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 253 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 207 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 56 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "1471": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 159, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 35, + "start_line": 213 + }, + "While expanding the reference 'final' in:" + ], + "start_col": 5, + "start_line": 159 + } + }, + "1472": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 155, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 83, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 63, + "start_line": 213 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 155 + } + }, + "1473": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 213 + } + }, + "1475": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + } + }, + "1476": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 219, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 219 + } + }, + "1478": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 219, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 219 + } + }, + "1480": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1b43ef6b4af8e72427aa5dbe8c8bae252da7027ca95f7e3d957ba8a9c97db773.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 222, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 220 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 253 + } + }, + "1481": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 90, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1b43ef6b4af8e72427aa5dbe8c8bae252da7027ca95f7e3d957ba8a9c97db773.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 222, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 220 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 55, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 253 + } + }, + "1482": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 156, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 221, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 24, + "start_line": 221 + }, + "While expanding the reference 'eic_hash' in:" + ], + "start_col": 5, + "start_line": 156 + } + }, + "1483": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 157, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 221, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 50, + "start_line": 221 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 157 + } + }, + "1484": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 90, + "end_line": 221, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 79, + "start_line": 221 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 158 + } + }, + "1485": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 222, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 220 + } + }, + "1487": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1b43ef6b4af8e72427aa5dbe8c8bae252da7027ca95f7e3d957ba8a9c97db773.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 222, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 223, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 223 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 154 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 9, + "start_line": 220 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 34, + "start_line": 1 + } + }, + "1488": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 223, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 223 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 38, + "start_line": 154 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + } + }, + "1489": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/ExternalInitializer/eic_initialize/1b43ef6b4af8e72427aa5dbe8c8bae252da7027ca95f7e3d957ba8a9c97db773.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 13, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 222, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 223, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 223 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 67, + "start_line": 154 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 9, + "start_line": 220 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 13 + }, + "While handling contract interface function:" + ], + "start_col": 55, + "start_line": 1 + } + }, + "1490": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 223, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 223 + } + }, + "1491": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 50, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 230, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 33, + "start_line": 228 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 253 + } + }, + "1492": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 90, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 230, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 33, + "start_line": 228 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 52, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 253 + } + }, + "1493": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 155, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 229, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 20, + "start_line": 229 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 155 + } + }, + "1494": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 230, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 33, + "start_line": 228 + } + }, + "1496": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 231, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 231 + } + }, + "1498": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 230, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/9d9536b18a319f36eeef57c36e532f983f44265fc7e39581e2aa4bf1393efc61.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 236, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 232 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 30, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 33, + "start_line": 228 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 1 + } + }, + "1499": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 230, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/9d9536b18a319f36eeef57c36e532f983f44265fc7e39581e2aa4bf1393efc61.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 236, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 232 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 51, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 33, + "start_line": 228 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 52, + "start_line": 1 + } + }, + "1500": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 155, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 233, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 24, + "start_line": 233 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 155 + } + }, + "1501": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 157, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 234, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 234 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 157 + } + }, + "1502": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 235, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 25, + "start_line": 235 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 158 + } + }, + "1503": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 10, + "end_line": 236, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 232 + } + }, + "1505": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/9d9536b18a319f36eeef57c36e532f983f44265fc7e39581e2aa4bf1393efc61.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 236, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 237, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 237 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 154 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 9, + "start_line": 232 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 30, + "start_line": 1 + } + }, + "1506": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 237, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 237 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 38, + "start_line": 154 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + } + }, + "1507": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialize/9d9536b18a319f36eeef57c36e532f983f44265fc7e39581e2aa4bf1393efc61.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 7, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 10, + "end_line": 236, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 237, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 237 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 67, + "start_line": 154 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 9, + "start_line": 232 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 7 + }, + "While handling contract interface function:" + ], + "start_col": 51, + "start_line": 1 + } + }, + "1508": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 237, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 237 + } + }, + "1509": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 230, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 239, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 239 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 154 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 33, + "start_line": 228 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 31, + "start_line": 1 + } + }, + "1510": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 84, + "end_line": 213, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 239, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 239 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 38, + "start_line": 154 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + }, + "While auto generating local variable for 'pedersen_ptr'." + ], + "start_col": 5, + "start_line": 213 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + } + }, + "1511": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/contract_interface/Initializable/initialized/89cd9f4a4b09fb174c25d920e19d5a76fe48b6e0e3390a04947865952dde580c.cairo" + }, + "parent_location": [ + { + "end_col": 21, + "end_line": 5, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/Initializable_interface.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 230, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 239, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 239 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 67, + "start_line": 154 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 33, + "start_line": 228 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 10, + "start_line": 5 + }, + "While handling contract interface function:" + ], + "start_col": 52, + "start_line": 1 + } + }, + "1512": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 239, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 239 + } + }, + "1513": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 158 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 2 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 67, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1514": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 157, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 158 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 28, + "start_line": 2 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 157 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1515": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 158 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1516": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 157, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 158 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 26, + "start_line": 8 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 157 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1518": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 157, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 158 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 43, + "start_line": 8 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 157 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1519": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 158 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 26, + "start_line": 8 + } + }, + "1520": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/7e43e5183ee46e00aab342ce0cb4c926a655274ff7f4f0d65a657711fbffdc3d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 159, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/5e1cc73f0b484f90bb02da164d88332b40c6f698801aa4d3c603dab22157e902.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While handling calldata of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__calldata_actual_size' in:" + ], + "start_col": 6, + "start_line": 154 + }, + "While handling calldata of" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 159 + }, + "While handling calldata argument 'final'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1522": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1523": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 158 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 23, + "start_line": 3 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 67, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1524": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "1525": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 38, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "1526": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 5, + "start_line": 158 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 23, + "start_line": 3 + } + }, + "1528": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 59, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/d2ee302a18234bed9fbd456e6c41abd6fb5413110dcab9643a9c66e4b29a240a.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 155, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 173, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 138, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 155 + }, + "While handling calldata argument 'implementation_hash_'" + ], + "start_col": 43, + "start_line": 1 + } + }, + "1529": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/eea8394a33414521e4ece8855a00f085f6843a8b97cef2bfb099279dfce7f148.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 156, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 207, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 184, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_eic_hash' in:" + ], + "start_col": 5, + "start_line": 156 + }, + "While handling calldata argument 'eic_hash'" + ], + "start_col": 31, + "start_line": 1 + } + }, + "1530": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 157, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 255, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 225, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 157 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1531": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 158, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 295, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 269, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_init_vector' in:" + ], + "start_col": 5, + "start_line": 158 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 34, + "start_line": 5 + } + }, + "1533": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/7e43e5183ee46e00aab342ce0cb4c926a655274ff7f4f0d65a657711fbffdc3d.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 159, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 323, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 303, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_final' in:" + ], + "start_col": 5, + "start_line": 159 + }, + "While handling calldata argument 'final'" + ], + "start_col": 28, + "start_line": 1 + } + }, + "1534": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + } + }, + "1536": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "1538": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "1539": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "1540": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "1541": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "1543": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4b177bd0a3d6c451bc81ed736744dff45bbfa54dd63afdb66200e05c71c209a5.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "1544": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/upgrade_to/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 154, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 154 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1545": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 248, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 20, + "start_line": 248 + } + }, + "1547": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 248, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 248 + } + }, + "1549": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 36, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 250, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 250 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 244 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 244 + } + }, + "1550": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 65, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 250, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 250 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 38, + "start_line": 244 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 38, + "start_line": 244 + } + }, + "1551": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 250, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 250 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 67, + "start_line": 244 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 67, + "start_line": 244 + } + }, + "1552": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 250, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 250 + } + }, + "1553": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 24, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 245 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 9, + "start_line": 2 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 67, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1554": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 58, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 245 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 28, + "start_line": 2 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 245 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1555": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 58, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 245 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 1, + "start_line": 2 + } + }, + "1556": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 245 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 26, + "start_line": 8 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 245 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1558": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 245 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 43, + "start_line": 8 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 245 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1559": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 77, + "end_line": 8, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 29, + "start_line": 245 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 26, + "start_line": 8 + } + }, + "1560": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1561": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 29, + "start_line": 245 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 23, + "start_line": 3 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 67, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1562": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 17, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "1563": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 38, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "1564": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 29, + "start_line": 245 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 23, + "start_line": 3 + } + }, + "1566": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 54, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/6df9e0229c1d6bf7a7ca011239d2f8cee22f765ff930b8d5ed61a301049bd9d0.cairo" + }, + "parent_location": [ + { + "end_col": 27, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 163, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 133, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_init_vector_len' in:" + ], + "start_col": 5, + "start_line": 245 + }, + "While handling calldata argument 'init_vector_len'" + ], + "start_col": 38, + "start_line": 1 + } + }, + "1567": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 61, + "end_line": 5, + "input_file": { + "filename": "autogen/starknet/arg_processor/cd6f268441c38a3f00a2b5f4f7f1f67eb745d3ca56895063e5e2c098507c663e.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 245, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 203, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 177, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_init_vector' in:" + ], + "start_col": 29, + "start_line": 245 + }, + "While handling calldata argument 'init_vector'" + ], + "start_col": 34, + "start_line": 5 + } + }, + "1569": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + } + }, + "1571": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "1573": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "1574": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "1575": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "1576": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "1578": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/initialize/e4fed9676c30b7b92e6686415332cb361fc6b6f075e5c75134347c99f2907c9b.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "1579": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/initialize/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 16, + "end_line": 244, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 6, + "start_line": 244 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1580": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 7, + "end_line": 256, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 256 + } + }, + "1582": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 257, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 257 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 253 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 253 + } + }, + "1583": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 257, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 257 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + } + }, + "1584": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 90, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 90, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 257, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 257 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 253 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 253 + } + }, + "1585": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 257, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 257 + } + }, + "1586": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 44, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 34, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 259, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 259 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 24 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 253 + } + }, + "1587": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 63, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 259, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 259 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 24 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + } + }, + "1588": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 90, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 259, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 259 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 24 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 253 + } + }, + "1589": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 19, + "end_line": 259, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 259 + } + }, + "1591": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 34, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 259, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 260, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 260 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 9, + "start_line": 259 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 15, + "start_line": 24 + } + }, + "1592": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 259, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 260, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 260 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 9, + "start_line": 259 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 65, + "start_line": 24 + } + }, + "1593": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 51, + "end_line": 254, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 79, + "end_line": 260, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 59, + "start_line": 260 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 24, + "start_line": 254 + } + }, + "1594": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 80, + "end_line": 260, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 260 + } + }, + "1596": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 30, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 260, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 44, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 261, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 261 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 253 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 9, + "start_line": 260 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 11, + "start_line": 1 + } + }, + "1597": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 63, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/finalizable.cairo" + }, + "parent_location": [ + { + "end_col": 19, + "end_line": 259, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 73, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 261, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 261 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 46, + "start_line": 253 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 9, + "start_line": 259 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 36, + "start_line": 24 + } + }, + "1598": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/event/implementation_finalized/061e12d2ab61277b9c9f3e137932ed9dc55f304b27d122b3d1541234d0033a6d.cairo" + }, + "parent_location": [ + { + "end_col": 30, + "end_line": 63, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 80, + "end_line": 260, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 90, + "end_line": 253, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 18, + "end_line": 261, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 261 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 75, + "start_line": 253 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 9, + "start_line": 260 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 63 + }, + "While handling event:" + ], + "start_col": 32, + "start_line": 1 + } + }, + "1599": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 18, + "end_line": 261, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 261 + } + }, + "1600": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 268, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 268 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 20, + "start_line": 148 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 30, + "start_line": 265 + } + }, + "1601": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 78, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 68, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 268, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 268 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 41, + "start_line": 148 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 51, + "start_line": 265 + } + }, + "1602": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 95, + "end_line": 265, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 85, + "end_line": 148, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/governance.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 268, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 268 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 70, + "start_line": 148 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 80, + "start_line": 265 + } + }, + "1603": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 268, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 268 + } + }, + "1605": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 23, + "end_line": 266, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 39, + "end_line": 269, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 28, + "start_line": 269 + }, + "While expanding the reference 'class_hash_' in:" + ], + "start_col": 5, + "start_line": 266 + } + }, + "1606": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 269, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 269 + } + }, + "1608": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 270, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 270 + } + }, + "1609": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 280, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 5, + "start_line": 280 + } + }, + "1611": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 43, + "end_line": 283, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 283 + } + }, + "1613": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 47, + "end_line": 273, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 32, + "end_line": 281, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 48, + "end_line": 44, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/cairo/common/hash_state.cairo" + }, + "parent_location": [ + { + "end_col": 88, + "end_line": 284, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 284 + }, + "While trying to retrieve the implicit argument 'hash_ptr' in:" + ], + "start_col": 25, + "start_line": 44 + }, + "While expanding the reference 'hash_ptr' in:" + ], + "start_col": 20, + "start_line": 281 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 20, + "start_line": 273 + } + }, + "1614": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 28, + "end_line": 283, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 65, + "end_line": 284, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 51, + "start_line": 284 + }, + "While expanding the reference 'hash_state_ptr' in:" + ], + "start_col": 14, + "start_line": 283 + } + }, + "1615": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 32, + "end_line": 274, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 87, + "end_line": 284, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 67, + "start_line": 284 + }, + "While expanding the reference 'implementation_hash_' in:" + ], + "start_col": 5, + "start_line": 274 + } + }, + "1616": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 88, + "end_line": 284, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 284 + } + }, + "1618": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 275, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 75, + "end_line": 285, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 67, + "start_line": 285 + }, + "While expanding the reference 'eic_hash' in:" + ], + "start_col": 5, + "start_line": 275 + } + }, + "1619": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 76, + "end_line": 285, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 285 + } + }, + "1621": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 276, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 286, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 67, + "start_line": 286 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 276 + } + }, + "1622": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 83, + "end_line": 286, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 286 + } + }, + "1624": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 24, + "end_line": 277, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 71, + "end_line": 287, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 60, + "start_line": 287 + }, + "While expanding the reference 'init_vector' in:" + ], + "start_col": 5, + "start_line": 277 + } + }, + "1625": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 27, + "end_line": 276, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 88, + "end_line": 287, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 73, + "start_line": 287 + }, + "While expanding the reference 'init_vector_len' in:" + ], + "start_col": 5, + "start_line": 276 + } + }, + "1626": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 89, + "end_line": 287, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 287 + } + }, + "1628": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 278, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 72, + "end_line": 288, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 67, + "start_line": 288 + }, + "While expanding the reference 'final' in:" + ], + "start_col": 5, + "start_line": 278 + } + }, + "1629": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 73, + "end_line": 288, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 32, + "start_line": 288 + } + }, + "1631": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 50, + "end_line": 289, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 21, + "start_line": 289 + } + }, + "1633": { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 25, + "end_line": 291, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "start_col": 9, + "start_line": 291 + } + }, + "1634": { + "accessible_scopes": ["__main__", "__main__", "__main__.constructor"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 27 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 16, + "start_line": 21 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 24 + } + }, + "1635": { + "accessible_scopes": ["__main__", "__main__", "__main__.constructor"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 64, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 27 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 37, + "start_line": 21 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 24 + } + }, + "1636": { + "accessible_scopes": ["__main__", "__main__", "__main__.constructor"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 83, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 81, + "end_line": 21, + "input_file": { + "filename": "autogen/starknet/storage_var/upgrade_delay/decl.cairo" + }, + "parent_location": [ + { + "end_col": 53, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 27 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 66, + "start_line": 21 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 24 + } + }, + "1637": { + "accessible_scopes": ["__main__", "__main__", "__main__.constructor"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 33, + "end_line": 25, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 52, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 31, + "start_line": 27 + }, + "While expanding the reference 'upgrade_delay_seconds' in:" + ], + "start_col": 5, + "start_line": 25 + } + }, + "1638": { + "accessible_scopes": ["__main__", "__main__", "__main__.constructor"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 53, + "end_line": 27, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 27 + } + }, + "1640": { + "accessible_scopes": ["__main__", "__main__", "__main__.constructor"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 28, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 28 + } + }, + "1641": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/arg_processor/a1a0b1df7500c649c93378b5d1c29f9be2447318df4cbac9173096fb323783fd.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 25, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 45, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/5e1cc73f0b484f90bb02da164d88332b40c6f698801aa4d3c603dab22157e902.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While handling calldata of" + ], + "start_col": 35, + "start_line": 1 + }, + "While expanding the reference '__calldata_actual_size' in:" + ], + "start_col": 6, + "start_line": 24 + }, + "While handling calldata of" + ], + "start_col": 31, + "start_line": 1 + }, + "While expanding the reference '__calldata_ptr' in:" + ], + "start_col": 5, + "start_line": 25 + }, + "While handling calldata argument 'upgrade_delay_seconds'" + ], + "start_col": 22, + "start_line": 2 + } + }, + "1643": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 57, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/1b562308a65653425ce06491fa4b4539466f3251a07e73e099d0afe86a48900e.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While handling calldata of" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1644": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "1645": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "1646": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 83, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1647": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/arg_processor/a1a0b1df7500c649c93378b5d1c29f9be2447318df4cbac9173096fb323783fd.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 25, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 175, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 139, + "start_line": 1 + }, + "While expanding the reference '__calldata_arg_upgrade_delay_seconds' in:" + ], + "start_col": 5, + "start_line": 25 + }, + "While handling calldata argument 'upgrade_delay_seconds'" + ], + "start_col": 44, + "start_line": 1 + } + }, + "1648": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + } + }, + "1650": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "1652": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "1653": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "1654": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "1655": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "1657": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/constructor/2dba460e0706a06ee2f1d9b2e58ef7b65dc6843de009ed76e0490bd5ea702047.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "1658": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/constructor/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 24, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 24 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1659": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 37, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 25, + "start_line": 37 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 34 + } + }, + "1660": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 66, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 25, + "start_line": 37 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 34 + } + }, + "1661": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 83, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 86, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 25, + "start_line": 37 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 67 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 34 + } + }, + "1662": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 25, + "start_line": 37 + } + }, + "1664": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 84, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 44, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 50, + "start_line": 39 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 84 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 37 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "1665": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 40, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 20, + "start_line": 40 + }, + "While expanding the reference 'class_hash_' in:" + ], + "start_col": 10, + "start_line": 37 + } + }, + "1666": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 35, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 41, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 27, + "start_line": 41 + }, + "While expanding the reference 'selector' in:" + ], + "start_col": 5, + "start_line": 35 + } + }, + "1667": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 35, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 42, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 23, + "start_line": 42 + }, + "While expanding the reference 'calldata_size' in:" + ], + "start_col": 22, + "start_line": 35 + } + }, + "1668": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 35, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 43, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 18, + "start_line": 43 + }, + "While expanding the reference 'calldata' in:" + ], + "start_col": 44, + "start_line": 35 + } + }, + "1669": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 44, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 50, + "start_line": 39 + } + }, + "1671": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 38, + "end_line": 84, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 44, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 45 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 34 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 50, + "start_line": 39 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 19, + "start_line": 84 + } + }, + "1672": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 45 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 34 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 25, + "start_line": 37 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + } + }, + "1673": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 86, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 37, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 83, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 56, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 45 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 34 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 25, + "start_line": 37 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 67 + } + }, + "1674": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 29, + "end_line": 39, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 38, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 26, + "start_line": 45 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 10, + "start_line": 39 + } + }, + "1675": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 46, + "end_line": 39, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 48, + "start_line": 45 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 31, + "start_line": 39 + } + }, + "1676": { + "accessible_scopes": ["__main__", "__main__", "__main__.__default__"], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 56, + "end_line": 45, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 45 + } + }, + "1677": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__default__/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 37, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__default__/594cfed774c45850575554a78093a7a27edf1e635eae6c967f967cde5f6d9051.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 18, + "start_line": 34 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "1678": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__default__/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 66, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__default__/594cfed774c45850575554a78093a7a27edf1e635eae6c967f967cde5f6d9051.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 39, + "start_line": 34 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "1679": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__default__/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 83, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__default__/594cfed774c45850575554a78093a7a27edf1e635eae6c967f967cde5f6d9051.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 68, + "start_line": 34 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1680": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 150, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__default__/594cfed774c45850575554a78093a7a27edf1e635eae6c967f967cde5f6d9051.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While constructing the external wrapper for:" + ], + "start_col": 126, + "start_line": 1 + } + }, + "1681": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 190, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__default__/594cfed774c45850575554a78093a7a27edf1e635eae6c967f967cde5f6d9051.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While constructing the external wrapper for:" + ], + "start_col": 166, + "start_line": 1 + } + }, + "1682": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 226, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__default__/594cfed774c45850575554a78093a7a27edf1e635eae6c967f967cde5f6d9051.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While constructing the external wrapper for:" + ], + "start_col": 201, + "start_line": 1 + } + }, + "1683": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 17, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 34 + } + }, + "1685": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__default__/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 17, + "end_line": 34, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 34 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + }, + "1686": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 53, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 25, + "start_line": 53 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 50 + } + }, + "1687": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 53, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 25, + "start_line": 53 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 50 + } + }, + "1688": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 86, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 86, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 53, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 25, + "start_line": 53 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 67 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 50 + } + }, + "1689": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 41, + "end_line": 53, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 25, + "start_line": 53 + } + }, + "1691": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 40, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 53, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 105, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 60, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 55 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 30, + "start_line": 105 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 25, + "start_line": 53 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 67 + } + }, + "1692": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 53, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 31, + "end_line": 56, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 20, + "start_line": 56 + }, + "While expanding the reference 'class_hash_' in:" + ], + "start_col": 10, + "start_line": 53 + } + }, + "1693": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 51, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 35, + "end_line": 57, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 27, + "start_line": 57 + }, + "While expanding the reference 'selector' in:" + ], + "start_col": 5, + "start_line": 51 + } + }, + "1694": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 42, + "end_line": 51, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 36, + "end_line": 58, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 23, + "start_line": 58 + }, + "While expanding the reference 'calldata_size' in:" + ], + "start_col": 22, + "start_line": 51 + } + }, + "1695": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 60, + "end_line": 51, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 26, + "end_line": 59, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 18, + "start_line": 59 + }, + "While expanding the reference 'calldata' in:" + ], + "start_col": 44, + "start_line": 51 + } + }, + "1696": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 6, + "end_line": 60, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 55 + } + }, + "1698": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 49, + "end_line": 105, + "input_file": { + "filename": "/app/build/Release/python_pip/python3.7/pip_cairo_lang/starkware/starknet/common/syscalls.cairo" + }, + "parent_location": [ + { + "end_col": 6, + "end_line": 60, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 61, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 61 + }, + "While trying to retrieve the implicit argument 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 50 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 5, + "start_line": 55 + }, + "While trying to update the implicit return value 'syscall_ptr' in:" + ], + "start_col": 30, + "start_line": 105 + } + }, + "1699": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 69, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 53, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 61, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 61 + }, + "While trying to retrieve the implicit argument 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 50 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 25, + "start_line": 53 + }, + "While trying to update the implicit return value 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 67 + } + }, + "1700": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 86, + "end_line": 67, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy_impl.cairo" + }, + "parent_location": [ + { + "end_col": 41, + "end_line": 53, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 86, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 14, + "end_line": 61, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 61 + }, + "While trying to retrieve the implicit argument 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 50 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 25, + "start_line": 53 + }, + "While trying to update the implicit return value 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 67 + } + }, + "1701": { + "accessible_scopes": [ + "__main__", + "__main__", + "__main__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 14, + "end_line": 61, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 5, + "start_line": 61 + } + }, + "1702": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 64, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/c7060df96cb0acca1380ae43bf758cab727bfdf73cb5d34a93e24a9742817fda.cairo" + }, + "parent_location": [ + { + "end_col": 40, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 21, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 19, + "start_line": 1 + } + }, + "1703": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 110, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/424b26e79f70343cc02557f1fbd25745138efb26a3dc5c8b593ca765b73138b7.cairo" + }, + "parent_location": [ + { + "end_col": 69, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 42, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 1 + } + }, + "1704": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 67, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/e651458745e7cd218121c342e0915890767e2f59ddc2e315b8844ad0f47d582e.cairo" + }, + "parent_location": [ + { + "end_col": 86, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 71, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 23, + "start_line": 1 + } + }, + "1705": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 150, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 126, + "start_line": 1 + } + }, + "1706": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 190, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 166, + "start_line": 1 + } + }, + "1707": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 226, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 201, + "start_line": 1 + } + }, + "1708": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + } + }, + "1710": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [ + { + "location": { + "end_col": 34, + "end_line": 2, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 2 + }, + "n_prefix_newlines": 0 + } + ], + "inst": { + "end_col": 24, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 3 + } + }, + "1712": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 55, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 1 + }, + "While expanding the reference 'syscall_ptr' in:" + ], + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 44, + "start_line": 1 + } + }, + "1713": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 82, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 33, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 21, + "start_line": 1 + }, + "While expanding the reference 'pedersen_ptr' in:" + ], + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 70, + "start_line": 1 + } + }, + "1714": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 115, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 49, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 34, + "start_line": 1 + }, + "While expanding the reference 'range_check_ptr' in:" + ], + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 100, + "start_line": 1 + } + }, + "1715": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 21, + "end_line": 4, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 62, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 50, + "start_line": 1 + }, + "While expanding the reference 'retdata_size' in:" + ], + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 20, + "start_line": 4 + } + }, + "1717": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 16, + "end_line": 3, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/edca83f6d2313d62fb8cc1b3fc4ae490d3e5ba3c3ba97a11fef2fe0adc8ace24.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "parent_location": [ + { + "end_col": 70, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 63, + "start_line": 1 + }, + "While expanding the reference 'retdata' in:" + ], + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 9, + "start_line": 3 + } + }, + "1718": { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "flow_tracking_data": null, + "hints": [], + "inst": { + "end_col": 71, + "end_line": 1, + "input_file": { + "filename": "autogen/starknet/external/__l1_default__/4ba2b119ceb30fe10f4cca3c9d73ef620c0fb5eece91b99a99d71217bba1001c.cairo" + }, + "parent_location": [ + { + "end_col": 20, + "end_line": 50, + "input_file": { + "filename": "/app/src/starkware/starknet/std_contracts/upgradability_proxy/proxy.cairo" + }, + "start_col": 6, + "start_line": 50 + }, + "While constructing the external wrapper for:" + ], + "start_col": 1, + "start_line": 1 + } + } + } + }, + "hints": { + "0": [ + { + "accessible_scopes": [ + "starkware.cairo.common.alloc", + "starkware.cairo.common.alloc.alloc" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 0, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "12": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "vm_enter_scope({'n': ids.len})", + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.len": 0 + } + } + } + ], + "20": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "n -= 1\nids.continue_copying = 1 if n > 0 else 0", + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 5 + }, + "reference_ids": { + "starkware.cairo.common.memcpy.memcpy.continue_copying": 1 + } + } + } + ], + "23": [ + { + "accessible_scopes": [ + "starkware.cairo.common.memcpy", + "starkware.cairo.common.memcpy.memcpy" + ], + "code": "vm_exit_scope()", + "flow_tracking_data": { + "ap_tracking": { + "group": 2, + "offset": 6 + }, + "reference_ids": {} + } + } + ], + "25": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_not_zero" + ], + "code": "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.value)\nassert ids.value % PRIME != 0, f'assert_not_zero failed: {ids.value} = 0.'", + "flow_tracking_data": { + "ap_tracking": { + "group": 4, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_not_zero.value": 2 + } + } + } + ], + "30": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_not_equal" + ], + "code": "from starkware.cairo.lang.vm.relocatable import RelocatableValue\nboth_ints = isinstance(ids.a, int) and isinstance(ids.b, int)\nboth_relocatable = (\n isinstance(ids.a, RelocatableValue) and isinstance(ids.b, RelocatableValue) and\n ids.a.segment_index == ids.b.segment_index)\nassert both_ints or both_relocatable, \\\n f'assert_not_equal failed: non-comparable values: {ids.a}, {ids.b}.'\nassert (ids.a - ids.b) % PRIME != 0, f'assert_not_equal failed: {ids.a} = {ids.b}.'", + "flow_tracking_data": { + "ap_tracking": { + "group": 5, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_not_equal.a": 3, + "starkware.cairo.common.math.assert_not_equal.b": 4 + } + } + } + ], + "36": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_nn" + ], + "code": "from starkware.cairo.common.math_utils import assert_integer\nassert_integer(ids.a)\nassert 0 <= ids.a % PRIME < range_check_builtin.bound, f'a = {ids.a} is out of range.'", + "flow_tracking_data": { + "ap_tracking": { + "group": 6, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_nn.a": 5 + } + } + } + ], + "45": [ + { + "accessible_scopes": [ + "starkware.cairo.common.math", + "starkware.cairo.common.math.assert_250_bit" + ], + "code": "from starkware.cairo.common.math_utils import as_int\n\n# Correctness check.\nvalue = as_int(ids.value, PRIME) % PRIME\nassert value < ids.UPPER_BOUND, f'{value} is outside of the range [0, 2**250).'\n\n# Calculation for the assertion.\nids.high, ids.low = divmod(ids.value, ids.SHIFT)", + "flow_tracking_data": { + "ap_tracking": { + "group": 8, + "offset": 0 + }, + "reference_ids": { + "starkware.cairo.common.math.assert_250_bit.high": 8, + "starkware.cairo.common.math.assert_250_bit.low": 7, + "starkware.cairo.common.math.assert_250_bit.value": 6 + } + } + } + ], + "60": [ + { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "code": "# Verify the assumptions on the relationship between 2**250, ADDR_BOUND and PRIME.\nADDR_BOUND = ids.ADDR_BOUND % PRIME\nassert (2**250 < ADDR_BOUND <= 2**251) and (2 * 2**250 < PRIME) and (\n ADDR_BOUND * 2 > PRIME), \\\n 'normalize_address() cannot be used with the current constants.'\nids.is_small = 1 if ids.addr < ADDR_BOUND else 0", + "flow_tracking_data": { + "ap_tracking": { + "group": 9, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.storage.normalize_address.addr": 9, + "starkware.starknet.common.storage.normalize_address.is_small": 10 + } + } + } + ], + "78": [ + { + "accessible_scopes": [ + "starkware.starknet.common.storage", + "starkware.starknet.common.storage.normalize_address" + ], + "code": "ids.is_250 = 1 if ids.addr < 2**250 else 0", + "flow_tracking_data": { + "ap_tracking": { + "group": 9, + "offset": 2 + }, + "reference_ids": { + "starkware.starknet.common.storage.normalize_address.addr": 9, + "starkware.starknet.common.storage.normalize_address.is_250": 11 + } + } + } + ], + "105": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call" + ], + "code": "syscall_handler.library_call(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 10, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.library_call.syscall_ptr": 12 + } + } + } + ], + "117": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.library_call_l1_handler" + ], + "code": "syscall_handler.library_call_l1_handler(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 11, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.library_call_l1_handler.syscall_ptr": 13 + } + } + } + ], + "125": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_caller_address" + ], + "code": "syscall_handler.get_caller_address(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 12, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.get_caller_address.syscall_ptr": 14 + } + } + } + ], + "132": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.get_block_timestamp" + ], + "code": "syscall_handler.get_block_timestamp(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 13, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.get_block_timestamp.syscall_ptr": 15 + } + } + } + ], + "140": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_read" + ], + "code": "syscall_handler.storage_read(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 14, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.storage_read.syscall_ptr": 16 + } + } + } + ], + "149": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.storage_write" + ], + "code": "syscall_handler.storage_write(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 15, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.storage_write.syscall_ptr": 17 + } + } + } + ], + "159": [ + { + "accessible_scopes": [ + "starkware.starknet.common.syscalls", + "starkware.starknet.common.syscalls.emit_event" + ], + "code": "syscall_handler.emit_event(segments=segments, syscall_ptr=ids.syscall_ptr)", + "flow_tracking_data": { + "ap_tracking": { + "group": 16, + "offset": 1 + }, + "reference_ids": { + "starkware.starknet.common.syscalls.emit_event.syscall_ptr": 18 + } + } + } + ], + "198": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "starkware.starknet.std_contracts.upgradability_proxy.finalizable", + "__wrappers__", + "__wrappers__.finalized_encode_return" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 21, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "461": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.is_governor_encode_return" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 39, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "531": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.init_governance" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 42, + "offset": 167 + }, + "reference_ids": {} + } + } + ], + "583": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.nominate_new_governor" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 46, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "636": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.cancel_nomination" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 50, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "688": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.remove_governor" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 54, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "736": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "starkware.starknet.std_contracts.upgradability_proxy.governance", + "__wrappers__", + "__wrappers__.accept_governance" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 56, + "offset": 219 + }, + "reference_ids": {} + } + } + ], + "1156": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_encode_return" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 86, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "1195": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.implementation_time_encode_return" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 90, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "1310": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.add_implementation" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 97, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "1393": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.remove_implementation" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 102, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "1536": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.upgrade_to" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 112, + "offset": 0 + }, + "reference_ids": {} + } + } + ], + "1571": [ + { + "accessible_scopes": [ + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl", + "__wrappers__", + "__wrappers__.initialize" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 114, + "offset": 17 + }, + "reference_ids": {} + } + } + ], + "1650": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.constructor" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 120, + "offset": 29 + }, + "reference_ids": {} + } + } + ], + "1710": [ + { + "accessible_scopes": [ + "__main__", + "__main__", + "__wrappers__", + "__wrappers__.__l1_default__" + ], + "code": "memory[ap] = segments.add()", + "flow_tracking_data": { + "ap_tracking": { + "group": 124, + "offset": 50 + }, + "reference_ids": {} + } + } + ] + }, + "identifiers": { + "__main__.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "__main__.__default__": { + "decorators": ["external", "raw_input", "raw_output"], + "pc": 1659, + "type": "function" + }, + "__main__.__default__.Args": { + "full_name": "__main__.__default__.Args", + "members": { + "calldata": { + "cairo_type": "felt*", + "offset": 2 + }, + "calldata_size": { + "cairo_type": "felt", + "offset": 1 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.__default__.ImplicitArgs": { + "full_name": "__main__.__default__.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.__default__.Return": { + "cairo_type": "(retdata_size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__main__.__default__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.__l1_default__": { + "decorators": ["l1_handler", "raw_input"], + "pc": 1686, + "type": "function" + }, + "__main__.__l1_default__.Args": { + "full_name": "__main__.__l1_default__.Args", + "members": { + "calldata": { + "cairo_type": "felt*", + "offset": 2 + }, + "calldata_size": { + "cairo_type": "felt", + "offset": 1 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.__l1_default__.ImplicitArgs": { + "full_name": "__main__.__l1_default__.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.__l1_default__.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.__l1_default__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.accept_governance": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance", + "type": "alias" + }, + "__main__.add_implementation": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation", + "type": "alias" + }, + "__main__.cancel_nomination": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination", + "type": "alias" + }, + "__main__.constructor": { + "decorators": ["constructor"], + "pc": 1634, + "type": "function" + }, + "__main__.constructor.Args": { + "full_name": "__main__.constructor.Args", + "members": { + "upgrade_delay_seconds": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "__main__.constructor.ImplicitArgs": { + "full_name": "__main__.constructor.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "__main__.constructor.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "__main__.constructor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__main__.finalized": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized", + "type": "alias" + }, + "__main__.implementation": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation", + "type": "alias" + }, + "__main__.init_governance": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance", + "type": "alias" + }, + "__main__.is_governor": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor", + "type": "alias" + }, + "__main__.library_call": { + "destination": "starkware.starknet.common.syscalls.library_call", + "type": "alias" + }, + "__main__.library_call_l1_handler": { + "destination": "starkware.starknet.common.syscalls.library_call_l1_handler", + "type": "alias" + }, + "__main__.nominate_new_governor": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor", + "type": "alias" + }, + "__main__.only_governor": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor", + "type": "alias" + }, + "__main__.remove_governor": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor", + "type": "alias" + }, + "__main__.remove_implementation": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation", + "type": "alias" + }, + "__main__.upgrade_delay": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay", + "type": "alias" + }, + "__main__.upgrade_to": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to", + "type": "alias" + }, + "__wrappers__.__default__": { + "decorators": ["external", "raw_input", "raw_output"], + "pc": 1677, + "type": "function" + }, + "__wrappers__.__default__.Args": { + "full_name": "__wrappers__.__default__.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__default__.ImplicitArgs": { + "full_name": "__wrappers__.__default__.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__default__.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.__default__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.__default__.__wrapped_func": { + "destination": "__main__.__default__", + "type": "alias" + }, + "__wrappers__.__default___encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.__l1_default__": { + "decorators": ["l1_handler", "raw_input"], + "pc": 1702, + "type": "function" + }, + "__wrappers__.__l1_default__.Args": { + "full_name": "__wrappers__.__l1_default__.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__l1_default__.ImplicitArgs": { + "full_name": "__wrappers__.__l1_default__.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.__l1_default__.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.__l1_default__.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.__l1_default__.__wrapped_func": { + "destination": "__main__.__l1_default__", + "type": "alias" + }, + "__wrappers__.__l1_default___encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.accept_governance": { + "decorators": ["external"], + "pc": 730, + "type": "function" + }, + "__wrappers__.accept_governance.Args": { + "full_name": "__wrappers__.accept_governance.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.accept_governance.ImplicitArgs": { + "full_name": "__wrappers__.accept_governance.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.accept_governance.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.accept_governance.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.accept_governance.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance", + "type": "alias" + }, + "__wrappers__.accept_governance_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.add_implementation": { + "decorators": ["external"], + "pc": 1287, + "type": "function" + }, + "__wrappers__.add_implementation.Args": { + "full_name": "__wrappers__.add_implementation.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.add_implementation.ImplicitArgs": { + "full_name": "__wrappers__.add_implementation.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.add_implementation.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.add_implementation.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.add_implementation.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation", + "type": "alias" + }, + "__wrappers__.add_implementation_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.cancel_nomination": { + "decorators": ["external"], + "pc": 627, + "type": "function" + }, + "__wrappers__.cancel_nomination.Args": { + "full_name": "__wrappers__.cancel_nomination.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.cancel_nomination.ImplicitArgs": { + "full_name": "__wrappers__.cancel_nomination.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.cancel_nomination.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.cancel_nomination.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.cancel_nomination.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination", + "type": "alias" + }, + "__wrappers__.cancel_nomination_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.constructor": { + "decorators": ["constructor"], + "pc": 1641, + "type": "function" + }, + "__wrappers__.constructor.Args": { + "full_name": "__wrappers__.constructor.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.constructor.ImplicitArgs": { + "full_name": "__wrappers__.constructor.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.constructor.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.constructor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.constructor.__wrapped_func": { + "destination": "__main__.constructor", + "type": "alias" + }, + "__wrappers__.constructor_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.finalized": { + "decorators": ["view"], + "pc": 207, + "type": "function" + }, + "__wrappers__.finalized.Args": { + "full_name": "__wrappers__.finalized.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.finalized.ImplicitArgs": { + "full_name": "__wrappers__.finalized.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.finalized.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.finalized.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.finalized.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized", + "type": "alias" + }, + "__wrappers__.finalized_encode_return": { + "decorators": [], + "pc": 198, + "type": "function" + }, + "__wrappers__.finalized_encode_return.Args": { + "full_name": "__wrappers__.finalized_encode_return.Args", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "ret_value": { + "cairo_type": "(res : felt)", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "__wrappers__.finalized_encode_return.ImplicitArgs": { + "full_name": "__wrappers__.finalized_encode_return.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.finalized_encode_return.Return": { + "cairo_type": "(range_check_ptr : felt, data_len : felt, data : felt*)", + "type": "type_definition" + }, + "__wrappers__.finalized_encode_return.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "__wrappers__.finalized_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.implementation": { + "decorators": ["view"], + "pc": 1165, + "type": "function" + }, + "__wrappers__.implementation.Args": { + "full_name": "__wrappers__.implementation.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.implementation.ImplicitArgs": { + "full_name": "__wrappers__.implementation.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.implementation.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.implementation.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.implementation.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation", + "type": "alias" + }, + "__wrappers__.implementation_encode_return": { + "decorators": [], + "pc": 1156, + "type": "function" + }, + "__wrappers__.implementation_encode_return.Args": { + "full_name": "__wrappers__.implementation_encode_return.Args", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "ret_value": { + "cairo_type": "(implementation_hash_ : felt)", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "__wrappers__.implementation_encode_return.ImplicitArgs": { + "full_name": "__wrappers__.implementation_encode_return.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.implementation_encode_return.Return": { + "cairo_type": "(range_check_ptr : felt, data_len : felt, data : felt*)", + "type": "type_definition" + }, + "__wrappers__.implementation_encode_return.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "__wrappers__.implementation_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.implementation_time": { + "decorators": ["view"], + "pc": 1204, + "type": "function" + }, + "__wrappers__.implementation_time.Args": { + "full_name": "__wrappers__.implementation_time.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.implementation_time.ImplicitArgs": { + "full_name": "__wrappers__.implementation_time.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.implementation_time.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.implementation_time.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.implementation_time.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time", + "type": "alias" + }, + "__wrappers__.implementation_time_encode_return": { + "decorators": [], + "pc": 1195, + "type": "function" + }, + "__wrappers__.implementation_time_encode_return.Args": { + "full_name": "__wrappers__.implementation_time_encode_return.Args", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "ret_value": { + "cairo_type": "(time : felt)", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "__wrappers__.implementation_time_encode_return.ImplicitArgs": { + "full_name": "__wrappers__.implementation_time_encode_return.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.implementation_time_encode_return.Return": { + "cairo_type": "(range_check_ptr : felt, data_len : felt, data : felt*)", + "type": "type_definition" + }, + "__wrappers__.implementation_time_encode_return.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "__wrappers__.implementation_time_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.init_governance": { + "decorators": ["external"], + "pc": 525, + "type": "function" + }, + "__wrappers__.init_governance.Args": { + "full_name": "__wrappers__.init_governance.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.init_governance.ImplicitArgs": { + "full_name": "__wrappers__.init_governance.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.init_governance.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.init_governance.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.init_governance.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance", + "type": "alias" + }, + "__wrappers__.init_governance_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.initialize": { + "decorators": ["external"], + "pc": 1553, + "type": "function" + }, + "__wrappers__.initialize.Args": { + "full_name": "__wrappers__.initialize.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.initialize.ImplicitArgs": { + "full_name": "__wrappers__.initialize.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.initialize.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.initialize.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.initialize.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize", + "type": "alias" + }, + "__wrappers__.initialize_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.is_governor": { + "decorators": ["view"], + "pc": 470, + "type": "function" + }, + "__wrappers__.is_governor.Args": { + "full_name": "__wrappers__.is_governor.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.is_governor.ImplicitArgs": { + "full_name": "__wrappers__.is_governor.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.is_governor.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.is_governor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.is_governor.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor", + "type": "alias" + }, + "__wrappers__.is_governor_encode_return": { + "decorators": [], + "pc": 461, + "type": "function" + }, + "__wrappers__.is_governor_encode_return.Args": { + "full_name": "__wrappers__.is_governor_encode_return.Args", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "ret_value": { + "cairo_type": "(is_governor_ : felt)", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "__wrappers__.is_governor_encode_return.ImplicitArgs": { + "full_name": "__wrappers__.is_governor_encode_return.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.is_governor_encode_return.Return": { + "cairo_type": "(range_check_ptr : felt, data_len : felt, data : felt*)", + "type": "type_definition" + }, + "__wrappers__.is_governor_encode_return.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "__wrappers__.is_governor_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.nominate_new_governor": { + "decorators": ["external"], + "pc": 574, + "type": "function" + }, + "__wrappers__.nominate_new_governor.Args": { + "full_name": "__wrappers__.nominate_new_governor.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.nominate_new_governor.ImplicitArgs": { + "full_name": "__wrappers__.nominate_new_governor.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.nominate_new_governor.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.nominate_new_governor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.nominate_new_governor.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor", + "type": "alias" + }, + "__wrappers__.nominate_new_governor_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.remove_governor": { + "decorators": ["external"], + "pc": 679, + "type": "function" + }, + "__wrappers__.remove_governor.Args": { + "full_name": "__wrappers__.remove_governor.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.remove_governor.ImplicitArgs": { + "full_name": "__wrappers__.remove_governor.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.remove_governor.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.remove_governor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.remove_governor.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor", + "type": "alias" + }, + "__wrappers__.remove_governor_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.remove_implementation": { + "decorators": ["external"], + "pc": 1370, + "type": "function" + }, + "__wrappers__.remove_implementation.Args": { + "full_name": "__wrappers__.remove_implementation.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.remove_implementation.ImplicitArgs": { + "full_name": "__wrappers__.remove_implementation.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.remove_implementation.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.remove_implementation.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.remove_implementation.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation", + "type": "alias" + }, + "__wrappers__.remove_implementation_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "__wrappers__.upgrade_to": { + "decorators": ["external"], + "pc": 1513, + "type": "function" + }, + "__wrappers__.upgrade_to.Args": { + "full_name": "__wrappers__.upgrade_to.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.upgrade_to.ImplicitArgs": { + "full_name": "__wrappers__.upgrade_to.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "__wrappers__.upgrade_to.Return": { + "cairo_type": "(syscall_ptr : felt*, pedersen_ptr : starkware.cairo.common.cairo_builtins.HashBuiltin*, range_check_ptr : felt, size : felt, retdata : felt*)", + "type": "type_definition" + }, + "__wrappers__.upgrade_to.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "__wrappers__.upgrade_to.__wrapped_func": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to", + "type": "alias" + }, + "__wrappers__.upgrade_to_encode_return.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.cairo.common.alloc.alloc": { + "decorators": [], + "pc": 0, + "type": "function" + }, + "starkware.cairo.common.alloc.alloc.Args": { + "full_name": "starkware.cairo.common.alloc.alloc.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.alloc.alloc.ImplicitArgs": { + "full_name": "starkware.cairo.common.alloc.alloc.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.alloc.alloc.Return": { + "cairo_type": "(ptr : felt*)", + "type": "type_definition" + }, + "starkware.cairo.common.alloc.alloc.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.bool.FALSE": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.bool.TRUE": { + "type": "const", + "value": 1 + }, + "starkware.cairo.common.cairo_builtins.BitwiseBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.BitwiseBuiltin", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "x_and_y": { + "cairo_type": "felt", + "offset": 2 + }, + "x_or_y": { + "cairo_type": "felt", + "offset": 4 + }, + "x_xor_y": { + "cairo_type": "felt", + "offset": 3 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.EcOpBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.EcOpBuiltin", + "members": { + "m": { + "cairo_type": "felt", + "offset": 4 + }, + "p": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 0 + }, + "q": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 2 + }, + "r": { + "cairo_type": "starkware.cairo.common.ec_point.EcPoint", + "offset": 5 + } + }, + "size": 7, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.EcPoint": { + "destination": "starkware.cairo.common.ec_point.EcPoint", + "type": "alias" + }, + "starkware.cairo.common.cairo_builtins.HashBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "members": { + "result": { + "cairo_type": "felt", + "offset": 2 + }, + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.cairo_builtins.SignatureBuiltin": { + "full_name": "starkware.cairo.common.cairo_builtins.SignatureBuiltin", + "members": { + "message": { + "cairo_type": "felt", + "offset": 1 + }, + "pub_key": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.dict_access.DictAccess": { + "full_name": "starkware.cairo.common.dict_access.DictAccess", + "members": { + "key": { + "cairo_type": "felt", + "offset": 0 + }, + "new_value": { + "cairo_type": "felt", + "offset": 2 + }, + "prev_value": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.ec_point.EcPoint": { + "full_name": "starkware.cairo.common.ec_point.EcPoint", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.common.hash.hash2": { + "decorators": [], + "pc": 3, + "type": "function" + }, + "starkware.cairo.common.hash.hash2.Args": { + "full_name": "starkware.cairo.common.hash.hash2.Args", + "members": { + "x": { + "cairo_type": "felt", + "offset": 0 + }, + "y": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash.hash2.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash.hash2.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash.hash2.Return": { + "cairo_type": "(result : felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash.hash2.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.hash_state.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.cairo.common.hash_state.HashState": { + "full_name": "starkware.cairo.common.hash_state.HashState", + "members": { + "current_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "n_words": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash_state.get_fp_and_pc": { + "destination": "starkware.cairo.common.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.common.hash_state.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "starkware.cairo.common.hash_state.hash_finalize": { + "decorators": [], + "pc": 802, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_finalize.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_finalize.Args", + "members": { + "hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_finalize.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_finalize.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_finalize.Return": { + "cairo_type": "(hash : felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_finalize.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.hash_state.hash_init": { + "decorators": [], + "pc": 760, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_init.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_init.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_init.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_init.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_init.Return": { + "cairo_type": "(hash_state_ptr : starkware.cairo.common.hash_state.HashState*)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_init.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.cairo.common.hash_state.hash_update": { + "decorators": [], + "pc": 770, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_update.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_update.Args", + "members": { + "data_length": { + "cairo_type": "felt", + "offset": 2 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 1 + }, + "hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_update.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update.Return": { + "cairo_type": "(new_hash_state_ptr : starkware.cairo.common.hash_state.HashState*)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_update.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.cairo.common.hash_state.hash_update_inner": { + "decorators": [], + "pc": 808, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_update_inner.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_update_inner.Args", + "members": { + "data_length": { + "cairo_type": "felt", + "offset": 1 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "hash": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update_inner.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_update_inner.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update_inner.LoopLocals": { + "full_name": "starkware.cairo.common.hash_state.hash_update_inner.LoopLocals", + "members": { + "cur_hash": { + "cairo_type": "felt", + "offset": 2 + }, + "data_ptr": { + "cairo_type": "felt*", + "offset": 0 + }, + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update_inner.Return": { + "cairo_type": "(hash : felt)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_update_inner.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "starkware.cairo.common.hash_state.hash_update_inner.hash_loop": { + "pc": 821, + "type": "label" + }, + "starkware.cairo.common.hash_state.hash_update_single": { + "decorators": [], + "pc": 786, + "type": "function" + }, + "starkware.cairo.common.hash_state.hash_update_single.Args": { + "full_name": "starkware.cairo.common.hash_state.hash_update_single.Args", + "members": { + "hash_state_ptr": { + "cairo_type": "starkware.cairo.common.hash_state.HashState*", + "offset": 0 + }, + "item": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update_single.ImplicitArgs": { + "full_name": "starkware.cairo.common.hash_state.hash_update_single.ImplicitArgs", + "members": { + "hash_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.hash_state.hash_update_single.Return": { + "cairo_type": "(new_hash_state_ptr : starkware.cairo.common.hash_state.HashState*)", + "type": "type_definition" + }, + "starkware.cairo.common.hash_state.hash_update_single.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.cairo.common.math.assert_250_bit": { + "decorators": ["known_ap_change"], + "pc": 45, + "type": "function" + }, + "starkware.cairo.common.math.assert_250_bit.Args": { + "full_name": "starkware.cairo.common.math.assert_250_bit.Args", + "members": { + "value": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_250_bit.HIGH_BOUND": { + "type": "const", + "value": 5316911983139663491615228241121378304 + }, + "starkware.cairo.common.math.assert_250_bit.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_250_bit.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_250_bit.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_250_bit.SHIFT": { + "type": "const", + "value": 340282366920938463463374607431768211456 + }, + "starkware.cairo.common.math.assert_250_bit.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_250_bit.UPPER_BOUND": { + "type": "const", + "value": 1809251394333065553493296640760748560207343510400633813116524750123642650624 + }, + "starkware.cairo.common.math.assert_250_bit.high": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_250_bit.high", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 45, + "value": "[cast([fp + (-4)] + 1, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_250_bit.low": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_250_bit.low", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 45, + "value": "[cast([fp + (-4)], felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_250_bit.value": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_250_bit.value", + "references": [ + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 45, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_le": { + "decorators": [], + "pc": 40, + "type": "function" + }, + "starkware.cairo.common.math.assert_le.Args": { + "full_name": "starkware.cairo.common.math.assert_le.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + }, + "b": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.math.assert_le.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_le.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_le.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_le.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_nn": { + "decorators": [], + "pc": 36, + "type": "function" + }, + "starkware.cairo.common.math.assert_nn.Args": { + "full_name": "starkware.cairo.common.math.assert_nn.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_nn.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_nn.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_nn.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_nn.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_nn.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_nn.a", + "references": [ + { + "ap_tracking_data": { + "group": 6, + "offset": 0 + }, + "pc": 36, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_not_equal": { + "decorators": [], + "pc": 30, + "type": "function" + }, + "starkware.cairo.common.math.assert_not_equal.Args": { + "full_name": "starkware.cairo.common.math.assert_not_equal.Args", + "members": { + "a": { + "cairo_type": "felt", + "offset": 0 + }, + "b": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.math.assert_not_equal.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_not_equal.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.math.assert_not_equal.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_not_equal.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_not_equal.a": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_not_equal.a", + "references": [ + { + "ap_tracking_data": { + "group": 5, + "offset": 0 + }, + "pc": 30, + "value": "[cast(fp + (-4), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_not_equal.b": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_not_equal.b", + "references": [ + { + "ap_tracking_data": { + "group": 5, + "offset": 0 + }, + "pc": 30, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.math.assert_not_zero": { + "decorators": [], + "pc": 25, + "type": "function" + }, + "starkware.cairo.common.math.assert_not_zero.Args": { + "full_name": "starkware.cairo.common.math.assert_not_zero.Args", + "members": { + "value": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.cairo.common.math.assert_not_zero.ImplicitArgs": { + "full_name": "starkware.cairo.common.math.assert_not_zero.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.math.assert_not_zero.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.math.assert_not_zero.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.math.assert_not_zero.value": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.math.assert_not_zero.value", + "references": [ + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 25, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy": { + "decorators": [], + "pc": 9, + "type": "function" + }, + "starkware.cairo.common.memcpy.memcpy.Args": { + "full_name": "starkware.cairo.common.memcpy.memcpy.Args", + "members": { + "dst": { + "cairo_type": "felt*", + "offset": 0 + }, + "len": { + "cairo_type": "felt", + "offset": 2 + }, + "src": { + "cairo_type": "felt*", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.ImplicitArgs": { + "full_name": "starkware.cairo.common.memcpy.memcpy.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.LoopFrame": { + "full_name": "starkware.cairo.common.memcpy.memcpy.LoopFrame", + "members": { + "dst": { + "cairo_type": "felt*", + "offset": 0 + }, + "src": { + "cairo_type": "felt*", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.cairo.common.memcpy.memcpy.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.cairo.common.memcpy.memcpy.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.cairo.common.memcpy.memcpy.continue_copying": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.memcpy.memcpy.continue_copying", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 16, + "value": "[cast(ap, felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.len": { + "cairo_type": "felt", + "full_name": "starkware.cairo.common.memcpy.memcpy.len", + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 9, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.cairo.common.memcpy.memcpy.loop": { + "pc": 14, + "type": "label" + }, + "starkware.cairo.common.registers.get_ap": { + "destination": "starkware.cairo.lang.compiler.lib.registers.get_ap", + "type": "alias" + }, + "starkware.cairo.common.registers.get_fp_and_pc": { + "destination": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc", + "type": "alias" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc": { + "decorators": [], + "pc": 24, + "type": "function" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Args": { + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.ImplicitArgs": { + "full_name": "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.Return": { + "cairo_type": "(fp_val : felt*, pc_val : felt*)", + "type": "type_definition" + }, + "starkware.cairo.lang.compiler.lib.registers.get_fp_and_pc.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.storage.ADDR_BOUND": { + "type": "const", + "value": -106710729501573572985208420194530329073740042555888586719489 + }, + "starkware.starknet.common.storage.MAX_STORAGE_ITEM_SIZE": { + "type": "const", + "value": 256 + }, + "starkware.starknet.common.storage.assert_250_bit": { + "destination": "starkware.cairo.common.math.assert_250_bit", + "type": "alias" + }, + "starkware.starknet.common.storage.normalize_address": { + "decorators": ["known_ap_change"], + "pc": 58, + "type": "function" + }, + "starkware.starknet.common.storage.normalize_address.Args": { + "full_name": "starkware.starknet.common.storage.normalize_address.Args", + "members": { + "addr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.storage.normalize_address.ImplicitArgs": { + "full_name": "starkware.starknet.common.storage.normalize_address.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.storage.normalize_address.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.common.storage.normalize_address.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.storage.normalize_address.addr": { + "cairo_type": "felt", + "full_name": "starkware.starknet.common.storage.normalize_address.addr", + "references": [ + { + "ap_tracking_data": { + "group": 9, + "offset": 0 + }, + "pc": 58, + "value": "[cast(fp + (-3), felt*)]" + } + ], + "type": "reference" + }, + "starkware.starknet.common.storage.normalize_address.is_250": { + "cairo_type": "felt", + "full_name": "starkware.starknet.common.storage.normalize_address.is_250", + "references": [ + { + "ap_tracking_data": { + "group": 9, + "offset": 2 + }, + "pc": 78, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.starknet.common.storage.normalize_address.is_small": { + "cairo_type": "felt", + "full_name": "starkware.starknet.common.storage.normalize_address.is_small", + "references": [ + { + "ap_tracking_data": { + "group": 9, + "offset": 1 + }, + "pc": 60, + "value": "[cast(ap + (-1), felt*)]" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.CALL_CONTRACT_SELECTOR": { + "type": "const", + "value": 20853273475220472486191784820 + }, + "starkware.starknet.common.syscalls.CallContract": { + "full_name": "starkware.starknet.common.syscalls.CallContract", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.CallContractRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.CallContractResponse", + "offset": 5 + } + }, + "size": 7, + "type": "struct" + }, + "starkware.starknet.common.syscalls.CallContractRequest": { + "full_name": "starkware.starknet.common.syscalls.CallContractRequest", + "members": { + "calldata": { + "cairo_type": "felt*", + "offset": 4 + }, + "calldata_size": { + "cairo_type": "felt", + "offset": 3 + }, + "contract_address": { + "cairo_type": "felt", + "offset": 1 + }, + "function_selector": { + "cairo_type": "felt", + "offset": 2 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.common.syscalls.CallContractResponse": { + "full_name": "starkware.starknet.common.syscalls.CallContractResponse", + "members": { + "retdata": { + "cairo_type": "felt*", + "offset": 1 + }, + "retdata_size": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.DELEGATE_CALL_SELECTOR": { + "type": "const", + "value": 21167594061783206823196716140 + }, + "starkware.starknet.common.syscalls.DELEGATE_L1_HANDLER_SELECTOR": { + "type": "const", + "value": 23274015802972845247556842986379118667122 + }, + "starkware.starknet.common.syscalls.DEPLOY_SELECTOR": { + "type": "const", + "value": 75202468540281 + }, + "starkware.starknet.common.syscalls.Deploy": { + "full_name": "starkware.starknet.common.syscalls.Deploy", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.DeployRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.DeployResponse", + "offset": 6 + } + }, + "size": 9, + "type": "struct" + }, + "starkware.starknet.common.syscalls.DeployRequest": { + "full_name": "starkware.starknet.common.syscalls.DeployRequest", + "members": { + "class_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "constructor_calldata": { + "cairo_type": "felt*", + "offset": 4 + }, + "constructor_calldata_size": { + "cairo_type": "felt", + "offset": 3 + }, + "contract_address_salt": { + "cairo_type": "felt", + "offset": 2 + }, + "reserved": { + "cairo_type": "felt", + "offset": 5 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 6, + "type": "struct" + }, + "starkware.starknet.common.syscalls.DeployResponse": { + "full_name": "starkware.starknet.common.syscalls.DeployResponse", + "members": { + "constructor_retdata": { + "cairo_type": "felt*", + "offset": 2 + }, + "constructor_retdata_size": { + "cairo_type": "felt", + "offset": 1 + }, + "contract_address": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.common.syscalls.DictAccess": { + "destination": "starkware.cairo.common.dict_access.DictAccess", + "type": "alias" + }, + "starkware.starknet.common.syscalls.EMIT_EVENT_SELECTOR": { + "type": "const", + "value": 1280709301550335749748 + }, + "starkware.starknet.common.syscalls.EmitEvent": { + "full_name": "starkware.starknet.common.syscalls.EmitEvent", + "members": { + "data": { + "cairo_type": "felt*", + "offset": 4 + }, + "data_len": { + "cairo_type": "felt", + "offset": 3 + }, + "keys": { + "cairo_type": "felt*", + "offset": 2 + }, + "keys_len": { + "cairo_type": "felt", + "offset": 1 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GET_BLOCK_NUMBER_SELECTOR": { + "type": "const", + "value": 1448089106835523001438702345020786 + }, + "starkware.starknet.common.syscalls.GET_BLOCK_TIMESTAMP_SELECTOR": { + "type": "const", + "value": 24294903732626645868215235778792757751152 + }, + "starkware.starknet.common.syscalls.GET_CALLER_ADDRESS_SELECTOR": { + "type": "const", + "value": 94901967781393078444254803017658102643 + }, + "starkware.starknet.common.syscalls.GET_CONTRACT_ADDRESS_SELECTOR": { + "type": "const", + "value": 6219495360805491471215297013070624192820083 + }, + "starkware.starknet.common.syscalls.GET_SEQUENCER_ADDRESS_SELECTOR": { + "type": "const", + "value": 1592190833581991703053805829594610833820054387 + }, + "starkware.starknet.common.syscalls.GET_TX_INFO_SELECTOR": { + "type": "const", + "value": 1317029390204112103023 + }, + "starkware.starknet.common.syscalls.GET_TX_SIGNATURE_SELECTOR": { + "type": "const", + "value": 1448089128652340074717162277007973 + }, + "starkware.starknet.common.syscalls.GetBlockNumber": { + "full_name": "starkware.starknet.common.syscalls.GetBlockNumber", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetBlockNumberRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetBlockNumberResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetBlockNumberRequest": { + "full_name": "starkware.starknet.common.syscalls.GetBlockNumberRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetBlockNumberResponse": { + "full_name": "starkware.starknet.common.syscalls.GetBlockNumberResponse", + "members": { + "block_number": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetBlockTimestamp": { + "full_name": "starkware.starknet.common.syscalls.GetBlockTimestamp", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetBlockTimestampRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetBlockTimestampResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetBlockTimestampRequest": { + "full_name": "starkware.starknet.common.syscalls.GetBlockTimestampRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetBlockTimestampResponse": { + "full_name": "starkware.starknet.common.syscalls.GetBlockTimestampResponse", + "members": { + "block_timestamp": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetCallerAddress": { + "full_name": "starkware.starknet.common.syscalls.GetCallerAddress", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetCallerAddressRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetCallerAddressResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetCallerAddressRequest": { + "full_name": "starkware.starknet.common.syscalls.GetCallerAddressRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetCallerAddressResponse": { + "full_name": "starkware.starknet.common.syscalls.GetCallerAddressResponse", + "members": { + "caller_address": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetContractAddress": { + "full_name": "starkware.starknet.common.syscalls.GetContractAddress", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetContractAddressRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetContractAddressResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetContractAddressRequest": { + "full_name": "starkware.starknet.common.syscalls.GetContractAddressRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetContractAddressResponse": { + "full_name": "starkware.starknet.common.syscalls.GetContractAddressResponse", + "members": { + "contract_address": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetSequencerAddress": { + "full_name": "starkware.starknet.common.syscalls.GetSequencerAddress", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetSequencerAddressRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetSequencerAddressResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetSequencerAddressRequest": { + "full_name": "starkware.starknet.common.syscalls.GetSequencerAddressRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetSequencerAddressResponse": { + "full_name": "starkware.starknet.common.syscalls.GetSequencerAddressResponse", + "members": { + "sequencer_address": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxInfo": { + "full_name": "starkware.starknet.common.syscalls.GetTxInfo", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetTxInfoRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetTxInfoResponse", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxInfoRequest": { + "full_name": "starkware.starknet.common.syscalls.GetTxInfoRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxInfoResponse": { + "full_name": "starkware.starknet.common.syscalls.GetTxInfoResponse", + "members": { + "tx_info": { + "cairo_type": "starkware.starknet.common.syscalls.TxInfo*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxSignature": { + "full_name": "starkware.starknet.common.syscalls.GetTxSignature", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.GetTxSignatureRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.GetTxSignatureResponse", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxSignatureRequest": { + "full_name": "starkware.starknet.common.syscalls.GetTxSignatureRequest", + "members": { + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.GetTxSignatureResponse": { + "full_name": "starkware.starknet.common.syscalls.GetTxSignatureResponse", + "members": { + "signature": { + "cairo_type": "felt*", + "offset": 1 + }, + "signature_len": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.LIBRARY_CALL_L1_HANDLER_SELECTOR": { + "type": "const", + "value": 436233452754198157705746250789557519228244616562 + }, + "starkware.starknet.common.syscalls.LIBRARY_CALL_SELECTOR": { + "type": "const", + "value": 92376026794327011772951660 + }, + "starkware.starknet.common.syscalls.LibraryCall": { + "full_name": "starkware.starknet.common.syscalls.LibraryCall", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.LibraryCallRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.CallContractResponse", + "offset": 5 + } + }, + "size": 7, + "type": "struct" + }, + "starkware.starknet.common.syscalls.LibraryCallRequest": { + "full_name": "starkware.starknet.common.syscalls.LibraryCallRequest", + "members": { + "calldata": { + "cairo_type": "felt*", + "offset": 4 + }, + "calldata_size": { + "cairo_type": "felt", + "offset": 3 + }, + "class_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "function_selector": { + "cairo_type": "felt", + "offset": 2 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.common.syscalls.SEND_MESSAGE_TO_L1_SELECTOR": { + "type": "const", + "value": 433017908768303439907196859243777073 + }, + "starkware.starknet.common.syscalls.STORAGE_READ_SELECTOR": { + "type": "const", + "value": 100890693370601760042082660 + }, + "starkware.starknet.common.syscalls.STORAGE_WRITE_SELECTOR": { + "type": "const", + "value": 25828017502874050592466629733 + }, + "starkware.starknet.common.syscalls.SendMessageToL1SysCall": { + "full_name": "starkware.starknet.common.syscalls.SendMessageToL1SysCall", + "members": { + "payload_ptr": { + "cairo_type": "felt*", + "offset": 3 + }, + "payload_size": { + "cairo_type": "felt", + "offset": 2 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + }, + "to_address": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.starknet.common.syscalls.StorageRead": { + "full_name": "starkware.starknet.common.syscalls.StorageRead", + "members": { + "request": { + "cairo_type": "starkware.starknet.common.syscalls.StorageReadRequest", + "offset": 0 + }, + "response": { + "cairo_type": "starkware.starknet.common.syscalls.StorageReadResponse", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.common.syscalls.StorageReadRequest": { + "full_name": "starkware.starknet.common.syscalls.StorageReadRequest", + "members": { + "address": { + "cairo_type": "felt", + "offset": 1 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.StorageReadResponse": { + "full_name": "starkware.starknet.common.syscalls.StorageReadResponse", + "members": { + "value": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.StorageWrite": { + "full_name": "starkware.starknet.common.syscalls.StorageWrite", + "members": { + "address": { + "cairo_type": "felt", + "offset": 1 + }, + "selector": { + "cairo_type": "felt", + "offset": 0 + }, + "value": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.common.syscalls.TxInfo": { + "full_name": "starkware.starknet.common.syscalls.TxInfo", + "members": { + "account_contract_address": { + "cairo_type": "felt", + "offset": 1 + }, + "chain_id": { + "cairo_type": "felt", + "offset": 6 + }, + "max_fee": { + "cairo_type": "felt", + "offset": 2 + }, + "signature": { + "cairo_type": "felt*", + "offset": 4 + }, + "signature_len": { + "cairo_type": "felt", + "offset": 3 + }, + "transaction_hash": { + "cairo_type": "felt", + "offset": 5 + }, + "version": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 7, + "type": "struct" + }, + "starkware.starknet.common.syscalls.emit_event": { + "decorators": [], + "pc": 152, + "type": "function" + }, + "starkware.starknet.common.syscalls.emit_event.Args": { + "full_name": "starkware.starknet.common.syscalls.emit_event.Args", + "members": { + "data": { + "cairo_type": "felt*", + "offset": 3 + }, + "data_len": { + "cairo_type": "felt", + "offset": 2 + }, + "keys": { + "cairo_type": "felt*", + "offset": 1 + }, + "keys_len": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.starknet.common.syscalls.emit_event.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.emit_event.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.emit_event.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.emit_event.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.emit_event.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.emit_event.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 152, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 1 + }, + "pc": 159, + "value": "cast([fp + (-7)] + 5, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.get_block_timestamp": { + "decorators": [], + "pc": 129, + "type": "function" + }, + "starkware.starknet.common.syscalls.get_block_timestamp.Args": { + "full_name": "starkware.starknet.common.syscalls.get_block_timestamp.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.common.syscalls.get_block_timestamp.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.get_block_timestamp.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.get_block_timestamp.Return": { + "cairo_type": "(block_timestamp : felt)", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.get_block_timestamp.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.get_block_timestamp.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.get_block_timestamp.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 129, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 1 + }, + "pc": 132, + "value": "cast([fp + (-3)] + 2, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.get_caller_address": { + "decorators": [], + "pc": 122, + "type": "function" + }, + "starkware.starknet.common.syscalls.get_caller_address.Args": { + "full_name": "starkware.starknet.common.syscalls.get_caller_address.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.common.syscalls.get_caller_address.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.get_caller_address.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.get_caller_address.Return": { + "cairo_type": "(caller_address : felt)", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.get_caller_address.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.get_caller_address.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.get_caller_address.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 12, + "offset": 0 + }, + "pc": 122, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 1 + }, + "pc": 125, + "value": "cast([fp + (-3)] + 2, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.library_call": { + "decorators": [], + "pc": 98, + "type": "function" + }, + "starkware.starknet.common.syscalls.library_call.Args": { + "full_name": "starkware.starknet.common.syscalls.library_call.Args", + "members": { + "calldata": { + "cairo_type": "felt*", + "offset": 3 + }, + "calldata_size": { + "cairo_type": "felt", + "offset": 2 + }, + "class_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "function_selector": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.starknet.common.syscalls.library_call.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.library_call.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.library_call.Return": { + "cairo_type": "(retdata_size : felt, retdata : felt*)", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.library_call.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.library_call.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.library_call.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 98, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 1 + }, + "pc": 105, + "value": "cast([fp + (-7)] + 7, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.library_call_l1_handler": { + "decorators": [], + "pc": 110, + "type": "function" + }, + "starkware.starknet.common.syscalls.library_call_l1_handler.Args": { + "full_name": "starkware.starknet.common.syscalls.library_call_l1_handler.Args", + "members": { + "calldata": { + "cairo_type": "felt*", + "offset": 3 + }, + "calldata_size": { + "cairo_type": "felt", + "offset": 2 + }, + "class_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "function_selector": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.starknet.common.syscalls.library_call_l1_handler.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.library_call_l1_handler.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.library_call_l1_handler.Return": { + "cairo_type": "(retdata_size : felt, retdata : felt*)", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.library_call_l1_handler.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.library_call_l1_handler.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.library_call_l1_handler.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 110, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 11, + "offset": 1 + }, + "pc": 117, + "value": "cast([fp + (-7)] + 7, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.storage_read": { + "decorators": [], + "pc": 136, + "type": "function" + }, + "starkware.starknet.common.syscalls.storage_read.Args": { + "full_name": "starkware.starknet.common.syscalls.storage_read.Args", + "members": { + "address": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.storage_read.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.storage_read.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.storage_read.Return": { + "cairo_type": "(value : felt)", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.storage_read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.storage_read.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.storage_read.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 14, + "offset": 0 + }, + "pc": 136, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 14, + "offset": 1 + }, + "pc": 140, + "value": "cast([fp + (-4)] + 3, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.common.syscalls.storage_write": { + "decorators": [], + "pc": 144, + "type": "function" + }, + "starkware.starknet.common.syscalls.storage_write.Args": { + "full_name": "starkware.starknet.common.syscalls.storage_write.Args", + "members": { + "address": { + "cairo_type": "felt", + "offset": 0 + }, + "value": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.common.syscalls.storage_write.ImplicitArgs": { + "full_name": "starkware.starknet.common.syscalls.storage_write.ImplicitArgs", + "members": { + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.common.syscalls.storage_write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.common.syscalls.storage_write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.common.syscalls.storage_write.syscall_ptr": { + "cairo_type": "felt*", + "full_name": "starkware.starknet.common.syscalls.storage_write.syscall_ptr", + "references": [ + { + "ap_tracking_data": { + "group": 15, + "offset": 0 + }, + "pc": 144, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 15, + "offset": 1 + }, + "pc": 149, + "value": "cast([fp + (-5)] + 3, felt*)" + } + ], + "type": "reference" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.EIC_INITIALIZE_SELECTOR": { + "type": "const", + "value": 1770792127795049777084697565458798191120226931451376769053057094489776256516 + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.call_contract": { + "destination": "starkware.starknet.common.syscalls.call_contract", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call": { + "destination": "starkware.starknet.common.syscalls.library_call", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize": { + "decorators": [], + "pc": 882, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize.Args", + "members": { + "class_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "init_vector": { + "cairo_type": "felt*", + "offset": 2 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.library_call_eic_initialize.SIZEOF_LOCALS": { + "type": "const", + "value": 3 + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.INITIALIZED_SELECTOR": { + "type": "const", + "value": 1697461057326310581967816530165551571743938660869987744467005324703617544296 + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.INITIALIZE_SELECTOR": { + "type": "const", + "value": 215307247182100370520050591091822763712463273430149262739280891880522753123 + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.call_contract": { + "destination": "starkware.starknet.common.syscalls.call_contract", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call": { + "destination": "starkware.starknet.common.syscalls.library_call", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize": { + "decorators": [], + "pc": 853, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize.Args", + "members": { + "class_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "init_vector": { + "cairo_type": "felt*", + "offset": 2 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialize.SIZEOF_LOCALS": { + "type": "const", + "value": 3 + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized": { + "decorators": [], + "pc": 833, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized.Args", + "members": { + "class_hash": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.library_call_initialized.SIZEOF_LOCALS": { + "type": "const", + "value": 1 + }, + "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.FALSE": { + "destination": "starkware.cairo.common.bool.FALSE", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.TRUE": { + "destination": "starkware.cairo.common.bool.TRUE", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr": { + "decorators": [], + "pc": 162, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.addr.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.normalize_address": { + "destination": "starkware.starknet.common.storage.normalize_address", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read": { + "decorators": [], + "pc": 167, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.storage_read": { + "destination": "starkware.starknet.common.syscalls.storage_read", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.storage_write": { + "destination": "starkware.starknet.common.syscalls.storage_write", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write": { + "decorators": [], + "pc": 180, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write.Args", + "members": { + "value": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable._finalized.write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize": { + "decorators": [], + "pc": 233, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized": { + "decorators": ["view"], + "pc": 192, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalized.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized": { + "decorators": [], + "pc": 222, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.FALSE": { + "destination": "starkware.cairo.common.bool.FALSE", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.TRUE": { + "destination": "starkware.cairo.common.bool.TRUE", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance": { + "decorators": ["external"], + "pc": 697, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.accept_governance.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.assert_not_equal": { + "destination": "starkware.cairo.common.math.assert_not_equal", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.assert_not_zero": { + "destination": "starkware.cairo.common.math.assert_not_zero", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination": { + "decorators": ["external"], + "pc": 592, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination.Args", + "members": { + "cancelee": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.cancel_nomination.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr": { + "decorators": [], + "pc": 314, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr.Args", + "members": { + "account": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.addr.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.normalize_address": { + "destination": "starkware.starknet.common.storage.normalize_address", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read": { + "decorators": [], + "pc": 328, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read.Args", + "members": { + "account": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read.Return": { + "cairo_type": "(governance_candidate : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.storage_read": { + "destination": "starkware.starknet.common.syscalls.storage_read", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.storage_write": { + "destination": "starkware.starknet.common.syscalls.storage_write", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write": { + "decorators": [], + "pc": 342, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write.Args", + "members": { + "account": { + "cairo_type": "felt", + "offset": 0 + }, + "value": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.candidates.write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.get_caller_address": { + "destination": "starkware.starknet.common.syscalls.get_caller_address", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.SELECTOR": { + "type": "const", + "value": 122941324927891101359770130551185202366109951608975274884288913291239215063 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit": { + "decorators": [], + "pc": 430, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit.Args", + "members": { + "new_governor": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.emit_event": { + "destination": "starkware.starknet.common.syscalls.emit_event", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_accepted.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr": { + "decorators": [], + "pc": 243, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.addr.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.normalize_address": { + "destination": "starkware.starknet.common.storage.normalize_address", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read": { + "decorators": [], + "pc": 248, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read.Return": { + "cairo_type": "(initialized : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.storage_read": { + "destination": "starkware.starknet.common.syscalls.storage_read", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.storage_write": { + "destination": "starkware.starknet.common.syscalls.storage_write", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write": { + "decorators": [], + "pc": 261, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write.Args", + "members": { + "value": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governance_initialized.write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.SELECTOR": { + "type": "const", + "value": 1567711119570952444663839893554579731710602646159332455291303348536112031027 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit": { + "decorators": [], + "pc": 355, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit.Args", + "members": { + "new_governor_nominee": { + "cairo_type": "felt", + "offset": 0 + }, + "nominated_by": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.emit_event": { + "destination": "starkware.starknet.common.syscalls.emit_event", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_nominated.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.SELECTOR": { + "type": "const", + "value": 1681447851982841018441568402694777178010403001644426944071619095562673034476 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit": { + "decorators": [], + "pc": 405, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit.Args", + "members": { + "removed_by": { + "cairo_type": "felt", + "offset": 1 + }, + "removed_governor": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.emit_event": { + "destination": "starkware.starknet.common.syscalls.emit_event", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governor_removed.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr": { + "decorators": [], + "pc": 273, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr.Args", + "members": { + "account": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.addr.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.normalize_address": { + "destination": "starkware.starknet.common.storage.normalize_address", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read": { + "decorators": [], + "pc": 287, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read.Args", + "members": { + "account": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read.Return": { + "cairo_type": "(active_governor : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.storage_read": { + "destination": "starkware.starknet.common.syscalls.storage_read", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.storage_write": { + "destination": "starkware.starknet.common.syscalls.storage_write", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write": { + "decorators": [], + "pc": 301, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write.Args", + "members": { + "account": { + "cairo_type": "felt", + "offset": 0 + }, + "value": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.governors.write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance": { + "decorators": ["external"], + "pc": 488, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.init_governance.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor": { + "decorators": ["view"], + "pc": 454, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor.Args", + "members": { + "account": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor.Return": { + "cairo_type": "(is_governor_ : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.is_governor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor": { + "decorators": ["external"], + "pc": 540, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor.Args", + "members": { + "nominee": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nominate_new_governor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.SELECTOR": { + "type": "const", + "value": 726254128209885463109714554301787105498069154916764786634959966930567421667 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit": { + "decorators": [], + "pc": 380, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit.Args", + "members": { + "cancelled_by": { + "cairo_type": "felt", + "offset": 1 + }, + "cancelled_nominee": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.emit_event": { + "destination": "starkware.starknet.common.syscalls.emit_event", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.nomination_cancelled.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor": { + "decorators": [], + "pc": 745, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor": { + "decorators": ["external"], + "pc": 645, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor.Args", + "members": { + "removee": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.governance.remove_governor.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.ExternalInitializer": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.ExternalInitializer", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.FALSE": { + "destination": "starkware.cairo.common.bool.FALSE", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.Initializable": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.Initializable_interface.Initializable", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.TRUE": { + "destination": "starkware.cairo.common.bool.TRUE", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation": { + "decorators": ["external"], + "pc": 1236, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation.Args", + "members": { + "eic_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "final": { + "cairo_type": "felt", + "offset": 4 + }, + "implementation_hash_": { + "cairo_type": "felt", + "offset": 0 + }, + "init_vector": { + "cairo_type": "felt*", + "offset": 3 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.add_implementation.SIZEOF_LOCALS": { + "type": "const", + "value": 5 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.assert_le": { + "destination": "starkware.cairo.common.math.assert_le", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.assert_not_zero": { + "destination": "starkware.cairo.common.math.assert_not_zero", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key": { + "decorators": [], + "pc": 1609, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key.Args", + "members": { + "eic_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "final": { + "cairo_type": "felt", + "offset": 4 + }, + "implementation_hash_": { + "cairo_type": "felt", + "offset": 0 + }, + "init_vector": { + "cairo_type": "felt*", + "offset": 3 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.calc_impl_key.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr": { + "decorators": [], + "pc": 982, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.addr.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.normalize_address": { + "destination": "starkware.starknet.common.storage.normalize_address", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read": { + "decorators": [], + "pc": 987, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read.Return": { + "cairo_type": "(hash : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.storage_read": { + "destination": "starkware.starknet.common.syscalls.storage_read", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.storage_write": { + "destination": "starkware.starknet.common.syscalls.storage_write", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write": { + "decorators": [], + "pc": 1000, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write.Args", + "members": { + "value": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.class_hash.write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.finalize": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.finalizable.finalize", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.get_block_timestamp": { + "destination": "starkware.starknet.common.syscalls.get_block_timestamp", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.hash_finalize": { + "destination": "starkware.cairo.common.hash_state.hash_finalize", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.hash_init": { + "destination": "starkware.cairo.common.hash_state.hash_init", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.hash_update": { + "destination": "starkware.cairo.common.hash_state.hash_update", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.hash_update_single": { + "destination": "starkware.cairo.common.hash_state.hash_update_single", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr": { + "decorators": [], + "pc": 941, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr.Args", + "members": { + "key": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.addr.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.normalize_address": { + "destination": "starkware.starknet.common.storage.normalize_address", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read": { + "decorators": [], + "pc": 955, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read.Args", + "members": { + "key": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read.Return": { + "cairo_type": "(ready_time : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.storage_read": { + "destination": "starkware.starknet.common.syscalls.storage_read", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.storage_write": { + "destination": "starkware.starknet.common.syscalls.storage_write", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write": { + "decorators": [], + "pc": 969, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write.Args", + "members": { + "key": { + "cairo_type": "felt", + "offset": 0 + }, + "value": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.impl_activation_time.write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation": { + "decorators": ["view"], + "pc": 1150, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation.Return": { + "cairo_type": "(implementation_hash_ : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.SELECTOR": { + "type": "const", + "value": 1315672471950616369479972321861946210736084026414030529222734321877576604190 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit": { + "decorators": [], + "pc": 1012, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit.Args", + "members": { + "eic_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "final": { + "cairo_type": "felt", + "offset": 4 + }, + "implementation_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "init_vector": { + "cairo_type": "felt*", + "offset": 3 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit.SIZEOF_LOCALS": { + "type": "const", + "value": 4 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.emit_event": { + "destination": "starkware.starknet.common.syscalls.emit_event", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_added.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.SELECTOR": { + "type": "const", + "value": 1256019443845162887772317145231898984631413081984266590366820562378534914338 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit": { + "decorators": [], + "pc": 1126, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit.Args", + "members": { + "implementation_hash": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit.SIZEOF_LOCALS": { + "type": "const", + "value": 2 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.emit_event": { + "destination": "starkware.starknet.common.syscalls.emit_event", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_finalized.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.SELECTOR": { + "type": "const", + "value": 1779702914585481320985194321878663664599848564032291022251970113439269195628 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit": { + "decorators": [], + "pc": 1051, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit.Args", + "members": { + "eic_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "final": { + "cairo_type": "felt", + "offset": 4 + }, + "implementation_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "init_vector": { + "cairo_type": "felt*", + "offset": 3 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit.SIZEOF_LOCALS": { + "type": "const", + "value": 4 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.emit_event": { + "destination": "starkware.starknet.common.syscalls.emit_event", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_removed.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time": { + "decorators": ["view"], + "pc": 1180, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time.Args", + "members": { + "eic_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "final": { + "cairo_type": "felt", + "offset": 4 + }, + "implementation_hash_": { + "cairo_type": "felt", + "offset": 0 + }, + "init_vector": { + "cairo_type": "felt*", + "offset": 3 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time.Return": { + "cairo_type": "(time : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_time.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.SELECTOR": { + "type": "const", + "value": 509506113054385003903725282836392490331709332709967545719058829557420296019 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.alloc": { + "destination": "starkware.cairo.common.alloc.alloc", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit": { + "decorators": [], + "pc": 1090, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit.Args", + "members": { + "eic_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "implementation_hash": { + "cairo_type": "felt", + "offset": 0 + }, + "init_vector": { + "cairo_type": "felt*", + "offset": 3 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 4, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit.ImplicitArgs", + "members": { + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit.SIZEOF_LOCALS": { + "type": "const", + "value": 4 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.emit_event": { + "destination": "starkware.starknet.common.syscalls.emit_event", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.implementation_upgraded.memcpy": { + "destination": "starkware.cairo.common.memcpy.memcpy", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize": { + "decorators": ["external"], + "pc": 1545, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize.Args", + "members": { + "init_vector": { + "cairo_type": "felt*", + "offset": 1 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.initialize.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.not_finalized": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.finalizable.not_finalized", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.only_governor": { + "destination": "starkware.starknet.std_contracts.upgradability_proxy.governance.only_governor", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag": { + "decorators": [], + "pc": 1580, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag.Args", + "members": { + "final_flag": { + "cairo_type": "felt", + "offset": 0 + }, + "implementation_hash_": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.process_final_flag.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation": { + "decorators": ["external"], + "pc": 1319, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation.Args", + "members": { + "eic_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "final": { + "cairo_type": "felt", + "offset": 4 + }, + "implementation_hash_": { + "cairo_type": "felt", + "offset": 0 + }, + "init_vector": { + "cairo_type": "felt*", + "offset": 3 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.remove_implementation.SIZEOF_LOCALS": { + "type": "const", + "value": 3 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash": { + "decorators": [], + "pc": 1600, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash.Args", + "members": { + "class_hash_": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.set_implementation_hash.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay": { + "type": "namespace" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.HashBuiltin": { + "destination": "starkware.cairo.common.cairo_builtins.HashBuiltin", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.ImplicitArgs", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr": { + "decorators": [], + "pc": 911, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 0 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 1 + } + }, + "size": 2, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr.Return": { + "cairo_type": "(res : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.addr.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.hash2": { + "destination": "starkware.cairo.common.hash.hash2", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.normalize_address": { + "destination": "starkware.starknet.common.storage.normalize_address", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read": { + "decorators": [], + "pc": 916, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read.Args", + "members": {}, + "size": 0, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read.Return": { + "cairo_type": "(delay_seconds : felt)", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.read.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.storage_read": { + "destination": "starkware.starknet.common.syscalls.storage_read", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.storage_write": { + "destination": "starkware.starknet.common.syscalls.storage_write", + "type": "alias" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write": { + "decorators": [], + "pc": 929, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write.Args", + "members": { + "value": { + "cairo_type": "felt", + "offset": 0 + } + }, + "size": 1, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_delay.write.SIZEOF_LOCALS": { + "type": "const", + "value": 0 + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to": { + "decorators": ["external"], + "pc": 1402, + "type": "function" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to.Args": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to.Args", + "members": { + "eic_hash": { + "cairo_type": "felt", + "offset": 1 + }, + "final": { + "cairo_type": "felt", + "offset": 4 + }, + "implementation_hash_": { + "cairo_type": "felt", + "offset": 0 + }, + "init_vector": { + "cairo_type": "felt*", + "offset": 3 + }, + "init_vector_len": { + "cairo_type": "felt", + "offset": 2 + } + }, + "size": 5, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to.ImplicitArgs": { + "full_name": "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to.ImplicitArgs", + "members": { + "pedersen_ptr": { + "cairo_type": "starkware.cairo.common.cairo_builtins.HashBuiltin*", + "offset": 1 + }, + "range_check_ptr": { + "cairo_type": "felt", + "offset": 2 + }, + "syscall_ptr": { + "cairo_type": "felt*", + "offset": 0 + } + }, + "size": 3, + "type": "struct" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to.Return": { + "cairo_type": "()", + "type": "type_definition" + }, + "starkware.starknet.std_contracts.upgradability_proxy.proxy_impl.upgrade_to.SIZEOF_LOCALS": { + "type": "const", + "value": 9 + } + }, + "main_scope": "__main__", + "prime": "0x800000000000011000000000000000000000000000000000000000000000001", + "reference_manager": { + "references": [ + { + "ap_tracking_data": { + "group": 2, + "offset": 0 + }, + "pc": 9, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 2, + "offset": 3 + }, + "pc": 16, + "value": "[cast(ap, felt*)]" + }, + { + "ap_tracking_data": { + "group": 4, + "offset": 0 + }, + "pc": 25, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 5, + "offset": 0 + }, + "pc": 30, + "value": "[cast(fp + (-4), felt*)]" + }, + { + "ap_tracking_data": { + "group": 5, + "offset": 0 + }, + "pc": 30, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 6, + "offset": 0 + }, + "pc": 36, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 45, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 45, + "value": "[cast([fp + (-4)], felt*)]" + }, + { + "ap_tracking_data": { + "group": 8, + "offset": 0 + }, + "pc": 45, + "value": "[cast([fp + (-4)] + 1, felt*)]" + }, + { + "ap_tracking_data": { + "group": 9, + "offset": 0 + }, + "pc": 58, + "value": "[cast(fp + (-3), felt*)]" + }, + { + "ap_tracking_data": { + "group": 9, + "offset": 1 + }, + "pc": 60, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 9, + "offset": 2 + }, + "pc": 78, + "value": "[cast(ap + (-1), felt*)]" + }, + { + "ap_tracking_data": { + "group": 10, + "offset": 0 + }, + "pc": 98, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 11, + "offset": 0 + }, + "pc": 110, + "value": "[cast(fp + (-7), felt**)]" + }, + { + "ap_tracking_data": { + "group": 12, + "offset": 0 + }, + "pc": 122, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 13, + "offset": 0 + }, + "pc": 129, + "value": "[cast(fp + (-3), felt**)]" + }, + { + "ap_tracking_data": { + "group": 14, + "offset": 0 + }, + "pc": 136, + "value": "[cast(fp + (-4), felt**)]" + }, + { + "ap_tracking_data": { + "group": 15, + "offset": 0 + }, + "pc": 144, + "value": "[cast(fp + (-5), felt**)]" + }, + { + "ap_tracking_data": { + "group": 16, + "offset": 0 + }, + "pc": 152, + "value": "[cast(fp + (-7), felt**)]" + } + ] + } + } +} diff --git a/starknet-rpc-test/declareV0.rs b/starknet-rpc-test/declareV0.rs new file mode 100644 index 0000000000..dce0504590 --- /dev/null +++ b/starknet-rpc-test/declareV0.rs @@ -0,0 +1,61 @@ +extern crate starknet_rpc_test; +use std::sync::Arc; + +use assert_matches::assert_matches; +use mp_transactions::BroadcastedDeclareTransactionV0; +use rstest::rstest; +use serde_json::json; +use starknet_core::types::contract::legacy::LegacyContractClass; +use starknet_core::types::{BlockId, BlockTag, ContractClass}; +use starknet_ff::FieldElement; +use starknet_providers::Provider; +use starknet_rpc_test::constants::ARGENT_CONTRACT_ADDRESS; +use starknet_test_utils::fixtures::{madara, ThreadSafeMadaraClient}; + +#[rstest] +#[tokio::test] +async fn add_declare_transaction_v0_works(madara: &ThreadSafeMadaraClient) { + let rpc = madara.get_starknet_client().await; + + let legacy_contract_class: LegacyContractClass = serde_json::from_reader( + std::fs::File::open(env!("CARGO_MANIFEST_DIR").to_owned() + "/" + "../starknet-rpc-test/contracts/proxy.json") + .unwrap(), + ) + .unwrap(); + let class_hash = legacy_contract_class.class_hash().unwrap(); + + let tx = BroadcastedDeclareTransactionV0 { + sender_address: FieldElement::from_hex_be(ARGENT_CONTRACT_ADDRESS).unwrap(), + // Amount used by the tx + max_fee: FieldElement::from(482250u128), + // No signature needed for DeclareV0 + signature: Vec::new(), + contract_class: Arc::new(legacy_contract_class.compress().unwrap()), + is_query: false, + }; + + let json_body = json!({ + "method": "madara_addDeclareTransactionV0", + "params": [tx], + }); + + let block_number = { + let mut madara_write_lock = madara.write().await; + // Wasn't declared before + assert!(rpc.get_class(BlockId::Tag(BlockTag::Latest), class_hash).await.is_err()); + madara_write_lock.call_rpc(json_body).await.unwrap(); + madara_write_lock.create_block_with_pending_txs().await.unwrap(); + rpc.block_number().await.unwrap() + }; + + // Tx was included in block + let block = match rpc.get_block_with_txs(BlockId::Number(block_number)).await.unwrap() { + starknet_core::types::MaybePendingBlockWithTxs::Block(b) => b, + _ => panic!("This block is not pending"), + }; + assert_eq!(block.transactions.len(), 1); + + // Is declared now + let contract_class = rpc.get_class(BlockId::Number(block_number), class_hash).await.unwrap(); + assert_matches!(contract_class, ContractClass::Legacy(_)); +} diff --git a/starknet-rpc-test/src/lib.rs b/starknet-rpc-test/src/lib.rs index 0494678284..0d3a4ab9be 100644 --- a/starknet-rpc-test/src/lib.rs +++ b/starknet-rpc-test/src/lib.rs @@ -125,7 +125,7 @@ impl MadaraClient { Ok(()) } - async fn call_rpc(&self, mut body: serde_json::Value) -> reqwest::Result { + pub async fn call_rpc(&self, mut body: serde_json::Value) -> reqwest::Result { let body = body.as_object_mut().expect("the body should be an object"); body.insert("id".to_string(), self.rpc_request_count.get().into()); body.insert("jsonrpc".to_string(), "2.0".into()); diff --git a/starknet-test-utils/src/lib.rs b/starknet-test-utils/src/lib.rs index 064c09c17f..d469d49701 100644 --- a/starknet-test-utils/src/lib.rs +++ b/starknet-test-utils/src/lib.rs @@ -122,7 +122,7 @@ impl MadaraClient { Ok(()) } - async fn call_rpc(&self, mut body: serde_json::Value) -> reqwest::Result { + pub async fn call_rpc(&self, mut body: serde_json::Value) -> reqwest::Result { let body = body.as_object_mut().expect("the body should be an object"); body.insert("id".to_string(), self.rpc_request_count.get().into()); body.insert("jsonrpc".to_string(), "2.0".into());