diff --git a/Cargo.lock b/Cargo.lock index 3ef97fa355e0b..d79aaf60f9753 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -682,6 +682,7 @@ dependencies = [ "aptos-metrics-core", "aptos-mvhashmap", "aptos-types", + "aptos-vm-environment", "aptos-vm-logging", "aptos-vm-types", "arc-swap", @@ -1645,6 +1646,7 @@ dependencies = [ name = "aptos-experimental-ptx-executor" version = "0.1.0" dependencies = [ + "aptos-crypto", "aptos-experimental-runtimes", "aptos-infallible", "aptos-logger", @@ -4492,6 +4494,7 @@ dependencies = [ "num_cpus", "once_cell", "ouroboros", + "parking_lot 0.12.1", "proptest", "rand 0.7.3", "rand_core 0.5.1", diff --git a/aptos-move/aptos-debugger/src/aptos_debugger.rs b/aptos-move/aptos-debugger/src/aptos_debugger.rs index 743bea9f09616..5560977d713b7 100644 --- a/aptos-move/aptos-debugger/src/aptos_debugger.rs +++ b/aptos-move/aptos-debugger/src/aptos_debugger.rs @@ -2,14 +2,12 @@ // SPDX-License-Identifier: Apache-2.0 use anyhow::{bail, format_err, Result}; -use aptos_block_executor::txn_commit_hook::NoOpTransactionCommitHook; +use aptos_crypto::HashValue; use aptos_gas_profiling::{GasProfiler, TransactionGasLog}; use aptos_rest_client::Client; use aptos_types::{ account_address::AccountAddress, - block_executor::config::{ - BlockExecutorConfig, BlockExecutorConfigFromOnchain, BlockExecutorLocalConfig, - }, + block_executor::config::BlockExecutorConfigFromOnchain, contract_event::ContractEvent, state_store::TStateView, transaction::{ @@ -23,9 +21,7 @@ use aptos_validator_interface::{ AptosValidatorInterface, DBDebuggerInterface, DebuggerStateView, RestDebuggerInterface, }; use aptos_vm::{ - block_executor::{AptosTransactionOutput, BlockAptosVM}, - data_cache::AsMoveResolver, - AptosVM, + aptos_vm::AptosVMBlockExecutor, data_cache::AsMoveResolver, AptosVM, VMBlockExecutor, }; use aptos_vm_environment::environment::AptosEnvironment; use aptos_vm_logging::log_schema::AdapterLogSchema; @@ -54,10 +50,13 @@ impl AptosDebugger { pub fn execute_transactions_at_version( &self, + executor: &AptosVMBlockExecutor, version: Version, txns: Vec, repeat_execution_times: u64, concurrency_levels: &[usize], + parent: Option<&HashValue>, + current: Option, ) -> Result> { let sig_verified_txns: Vec = txns.into_iter().map(|x| x.into()).collect::>(); @@ -70,9 +69,16 @@ impl AptosDebugger { for concurrency_level in concurrency_levels { for i in 0..repeat_execution_times { let start_time = Instant::now(); - let cur_result = - execute_block_no_limit(&sig_verified_txns, &state_view, *concurrency_level) - .map_err(|err| format_err!("Unexpected VM Error: {:?}", err))?; + let cur_result = executor + .execute_block( + &sig_verified_txns, + &state_view, + BlockExecutorConfigFromOnchain::new_no_block_limit(), + parent, + current, + ) + .map(BlockOutput::into_transaction_outputs_forced) + .map_err(|err| format_err!("Unexpected VM Error: {:?}", err))?; println!( "[{} txns from {}] Finished execution round {}/{} with concurrency_level={} in {}ms", @@ -169,14 +175,12 @@ impl AptosDebugger { if use_same_block_boundaries { // when going block by block, no need to worry about epoch boundaries // as new epoch is always a new block. - Ok(self - .execute_transactions_by_block( - begin, - txns.clone(), - repeat_execution_times, - concurrency_levels, - ) - .await?) + Ok(self.execute_transactions_by_block( + begin, + txns.clone(), + repeat_execution_times, + concurrency_levels, + )?) } else { self.execute_transactions_by_epoch( limit, @@ -228,16 +232,20 @@ impl AptosDebugger { async fn execute_transactions_until_epoch_end( &self, + executor: &AptosVMBlockExecutor, begin: Version, txns: Vec, repeat_execution_times: u64, concurrency_levels: &[usize], ) -> Result> { let results = self.execute_transactions_at_version( + executor, begin, txns, repeat_execution_times, concurrency_levels, + None, + None, )?; let mut ret = vec![]; let mut is_reconfig = false; @@ -270,8 +278,10 @@ impl AptosDebugger { begin, limit ); + let executor = AptosVMBlockExecutor::new(); let mut epoch_result = self .execute_transactions_until_epoch_end( + &executor, begin, txns.clone(), repeat_execution_times, @@ -289,7 +299,7 @@ impl AptosDebugger { Ok(ret) } - async fn execute_transactions_by_block( + fn execute_transactions_by_block( &self, begin: Version, txns: Vec, @@ -299,14 +309,20 @@ impl AptosDebugger { let mut ret = vec![]; let mut cur = vec![]; let mut cur_version = begin; + + let hash = HashValue::zero(); + let executor = AptosVMBlockExecutor::new(); for txn in txns { if txn.is_block_start() && !cur.is_empty() { let to_execute = std::mem::take(&mut cur); let results = self.execute_transactions_at_version( + &executor, cur_version, to_execute, repeat_execution_times, concurrency_levels, + Some(&hash), + Some(hash), )?; cur_version += results.len() as u64; ret.extend(results); @@ -315,10 +331,13 @@ impl AptosDebugger { } if !cur.is_empty() { let results = self.execute_transactions_at_version( + &executor, cur_version, cur, repeat_execution_times, concurrency_levels, + Some(&hash), + Some(hash), )?; ret.extend(results); } @@ -422,24 +441,3 @@ fn is_reconfiguration(vm_output: &TransactionOutput) -> bool { .iter() .any(ContractEvent::is_new_epoch_event) } - -fn execute_block_no_limit( - sig_verified_txns: &[SignatureVerifiedTransaction], - state_view: &DebuggerStateView, - concurrency_level: usize, -) -> Result, VMStatus> { - BlockAptosVM::execute_block::<_, NoOpTransactionCommitHook>( - sig_verified_txns, - state_view, - BlockExecutorConfig { - local: BlockExecutorLocalConfig { - concurrency_level, - allow_fallback: true, - discard_failed_blocks: false, - }, - onchain: BlockExecutorConfigFromOnchain::new_no_block_limit(), - }, - None, - ) - .map(BlockOutput::into_transaction_outputs_forced) -} diff --git a/aptos-move/aptos-debugger/src/execute_pending_block.rs b/aptos-move/aptos-debugger/src/execute_pending_block.rs index 7235dff6e9b01..b85f3382c3c2f 100644 --- a/aptos-move/aptos-debugger/src/execute_pending_block.rs +++ b/aptos-move/aptos-debugger/src/execute_pending_block.rs @@ -6,6 +6,7 @@ use anyhow::Result; use aptos_crypto::HashValue; use aptos_logger::info; use aptos_rest_client::Client; +use aptos_vm::{aptos_vm::AptosVMBlockExecutor, VMBlockExecutor}; use clap::Parser; use std::path::PathBuf; use url::Url; @@ -84,11 +85,15 @@ impl Command { user_txns }; + let executor = AptosVMBlockExecutor::new(); let txn_outputs = debugger.execute_transactions_at_version( + &executor, self.begin_version, block, self.repeat_execution_times.unwrap_or(1), &self.opts.concurrency_level, + None, + None, )?; println!("{txn_outputs:#?}"); diff --git a/aptos-move/aptos-transaction-benchmarks/src/transaction_bench_state.rs b/aptos-move/aptos-transaction-benchmarks/src/transaction_bench_state.rs index d3a71a1d22862..03355bab525f6 100644 --- a/aptos-move/aptos-transaction-benchmarks/src/transaction_bench_state.rs +++ b/aptos-move/aptos-transaction-benchmarks/src/transaction_bench_state.rs @@ -3,7 +3,9 @@ use crate::transactions; use aptos_bitvec::BitVec; -use aptos_block_executor::txn_commit_hook::NoOpTransactionCommitHook; +use aptos_block_executor::{ + code_cache_global_manager::ModuleCacheManager, txn_commit_hook::NoOpTransactionCommitHook, +}; use aptos_block_partitioner::{ v2::config::PartitionerV2Config, BlockPartitioner, PartitionerConfig, }; @@ -218,8 +220,11 @@ where >( transactions, self.state_view.as_ref(), + &ModuleCacheManager::new(), BlockExecutorConfig::new_maybe_block_limit(1, maybe_block_gas_limit), None, + None, + None, ) .expect("VM should not fail to start") .into_transaction_outputs_forced(); @@ -266,11 +271,14 @@ where >( transactions, self.state_view.as_ref(), + &ModuleCacheManager::new(), BlockExecutorConfig::new_maybe_block_limit( concurrency_level_per_shard, maybe_block_gas_limit, ), None, + None, + None, ) .expect("VM should not fail to start") .into_transaction_outputs_forced(); @@ -285,7 +293,7 @@ where partitioned_txns: Option, run_par: bool, run_seq: bool, - conurrency_level_per_shard: usize, + concurrency_level_per_shard: usize, maybe_block_gas_limit: Option, ) -> (usize, usize) { let (output, par_tps) = if run_par { @@ -293,13 +301,13 @@ where let (output, tps) = if self.is_shareded() { self.execute_benchmark_sharded( partitioned_txns.unwrap(), - conurrency_level_per_shard, + concurrency_level_per_shard, maybe_block_gas_limit, ) } else { self.execute_benchmark_parallel( &transactions, - conurrency_level_per_shard, + concurrency_level_per_shard, maybe_block_gas_limit, ) }; diff --git a/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs b/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs index 534608bfc2fac..a96506db49b47 100644 --- a/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs +++ b/aptos-move/aptos-transactional-test-harness/src/aptos_test_harness.rs @@ -14,11 +14,9 @@ use aptos_language_e2e_tests::data_store::{FakeDataStore, GENESIS_CHANGE_SET_HEA use aptos_resource_viewer::{AnnotatedMoveValue, AptosValueAnnotator}; use aptos_types::{ account_config::{aptos_test_root_address, AccountResource, CoinStoreResource}, - block_executor::config::BlockExecutorConfigFromOnchain, block_metadata::BlockMetadata, chain_id::ChainId, contract_event::ContractEvent, - on_chain_config::BlockGasLimitType, state_store::{state_key::StateKey, table::TableHandle, TStateView}, transaction::{ signature_verified_transaction::into_signature_verified_block, @@ -517,14 +515,8 @@ impl<'a> AptosTestAdapter<'a> { fn run_transaction(&mut self, txn: Transaction) -> Result { let txn_block = vec![txn]; let sig_verified_block = into_signature_verified_block(txn_block); - let onchain_config = BlockExecutorConfigFromOnchain { - // TODO fetch values from state? - // Or should we just use execute_block_no_limit ? - block_gas_limit_type: BlockGasLimitType::Limit(30000), - }; - let (mut outputs, _) = AptosVMBlockExecutor::new() - .execute_block(&sig_verified_block, &self.storage.clone(), onchain_config)? - .into_inner(); + let mut outputs = AptosVMBlockExecutor::new() + .execute_block_no_limit(&sig_verified_block, &self.storage.clone())?; assert_eq!(outputs.len(), 1); diff --git a/aptos-move/aptos-vm-environment/src/environment.rs b/aptos-move/aptos-vm-environment/src/environment.rs index 151dc19247ef9..e441b4d4c7971 100644 --- a/aptos-move/aptos-vm-environment/src/environment.rs +++ b/aptos-move/aptos-vm-environment/src/environment.rs @@ -15,7 +15,8 @@ use aptos_native_interface::SafeNativeBuilder; use aptos_types::{ chain_id::ChainId, on_chain_config::{ - ConfigurationResource, Features, OnChainConfig, TimedFeatures, TimedFeaturesBuilder, + ConfigurationResource, FeatureFlag, Features, OnChainConfig, TimedFeatures, + TimedFeaturesBuilder, }, state_store::StateView, }; @@ -175,8 +176,13 @@ impl Environment { ) -> Self { // We compute and store a hash of configs in order to distinguish different environments. let mut sha3_256 = Sha3_256::new(); - let features = + let mut features = fetch_config_and_update_hash::(&mut sha3_256, state_view).unwrap_or_default(); + if std::env::var("USE_LOADER_V2").is_ok() { + features.enable(FeatureFlag::ENABLE_LOADER_V2); + } else { + features.disable(FeatureFlag::ENABLE_LOADER_V2); + } // If no chain ID is in storage, we assume we are in a testing environment. let chain_id = fetch_config_and_update_hash::(&mut sha3_256, state_view) diff --git a/aptos-move/aptos-vm-profiling/src/bins/run_aptos_p2p.rs b/aptos-move/aptos-vm-profiling/src/bins/run_aptos_p2p.rs index c0972ced8a47a..02a5ed3c37a8c 100644 --- a/aptos-move/aptos-vm-profiling/src/bins/run_aptos_p2p.rs +++ b/aptos-move/aptos-vm-profiling/src/bins/run_aptos_p2p.rs @@ -48,9 +48,9 @@ fn main() -> Result<()> { }) .collect(); - let res = AptosVMBlockExecutor::new().execute_block_no_limit(&txns, &state_store)?; + let outputs = AptosVMBlockExecutor::new().execute_block_no_limit(&txns, &state_store)?; for i in 0..NUM_TXNS { - assert!(res[i as usize].status().status().unwrap().is_success()); + assert!(outputs[i as usize].status().status().unwrap().is_success()); } Ok(()) diff --git a/aptos-move/aptos-vm-types/src/module_and_script_storage/state_view_adapter.rs b/aptos-move/aptos-vm-types/src/module_and_script_storage/state_view_adapter.rs index c4aa089e28730..64627c634797d 100644 --- a/aptos-move/aptos-vm-types/src/module_and_script_storage/state_view_adapter.rs +++ b/aptos-move/aptos-vm-types/src/module_and_script_storage/state_view_adapter.rs @@ -3,22 +3,32 @@ use crate::module_and_script_storage::module_storage::AptosModuleStorage; use ambassador::Delegate; -use aptos_types::state_store::{state_key::StateKey, state_value::StateValueMetadata, StateView}; +use aptos_types::{ + error::PanicError, + state_store::{state_key::StateKey, state_value::StateValueMetadata, StateView, TStateView}, + vm::modules::AptosModuleExtension, +}; use bytes::Bytes; use move_binary_format::{ errors::{PartialVMResult, VMResult}, file_format::CompiledScript, CompiledModule, }; -use move_core_types::{account_address::AccountAddress, identifier::IdentStr, metadata::Metadata}; +use move_core_types::{ + account_address::AccountAddress, identifier::IdentStr, language_storage::ModuleId, + metadata::Metadata, +}; use move_vm_runtime::{ ambassador_impl_CodeStorage, ambassador_impl_ModuleStorage, ambassador_impl_WithRuntimeEnvironment, AsUnsyncCodeStorage, BorrowedOrOwned, CodeStorage, Module, ModuleStorage, RuntimeEnvironment, Script, UnsyncCodeStorage, UnsyncModuleStorage, WithRuntimeEnvironment, }; -use move_vm_types::{code::ModuleBytesStorage, module_storage_error}; -use std::sync::Arc; +use move_vm_types::{ + code::{ModuleBytesStorage, ModuleCode}, + module_storage_error, +}; +use std::{ops::Deref, sync::Arc}; /// Avoids orphan rule to implement [ModuleBytesStorage] for [StateView]. struct StateViewAdapter<'s, S> { @@ -38,6 +48,14 @@ impl<'s, S: StateView> ModuleBytesStorage for StateViewAdapter<'s, S> { } } +impl<'s, S: StateView> Deref for StateViewAdapter<'s, S> { + type Target = S; + + fn deref(&self) -> &Self::Target { + &self.state_view + } +} + /// A (not thread-safe) implementation of code storage on top of a state view. It is never built /// directly by clients - only via [AsAptosCodeStorage] trait. Can be used to resolve both modules /// and cached scripts. @@ -72,6 +90,57 @@ impl<'s, S: StateView, E: WithRuntimeEnvironment> AptosCodeStorageAdapter<'s, S, let storage = adapter.into_unsync_code_storage(runtime_environment); Self { storage } } + + /// Drains cached verified modules from the code storage, transforming them into format used by + /// global caches. + pub fn into_verified_module_code_iter( + self, + ) -> Result< + impl Iterator< + Item = ( + ModuleId, + Arc>, + ), + >, + PanicError, + > { + let (state_view, verified_modules_iter) = self + .storage + .into_module_storage() + .unpack_into_verified_modules_iter(); + + Ok(verified_modules_iter + .map(|(key, verified_code)| { + // We have cached the module previously, so we must be able to find it in storage. + let extension = state_view + .get_state_value(&StateKey::module_id(&key)) + .map_err(|err| { + let msg = format!( + "Failed to retrieve module {}::{} from storage {:?}", + key.address(), + key.name(), + err + ); + PanicError::CodeInvariantError(msg) + })? + .map_or_else( + || { + let msg = format!( + "Module {}::{} should exist, but it does not anymore", + key.address(), + key.name() + ); + Err(PanicError::CodeInvariantError(msg)) + }, + |state_value| Ok(AptosModuleExtension::new(state_value)), + )?; + + let module = ModuleCode::from_arced_verified(verified_code, Arc::new(extension)); + Ok((key, Arc::new(module))) + }) + .collect::, PanicError>>()? + .into_iter()) + } } impl<'s, S: StateView, E: WithRuntimeEnvironment> AptosModuleStorage diff --git a/aptos-move/aptos-vm/Cargo.toml b/aptos-move/aptos-vm/Cargo.toml index a3458288716d2..0afe74bebc4fb 100644 --- a/aptos-move/aptos-vm/Cargo.toml +++ b/aptos-move/aptos-vm/Cargo.toml @@ -55,6 +55,7 @@ move-vm-types = { workspace = true } num_cpus = { workspace = true } once_cell = { workspace = true } ouroboros = { workspace = true } +parking_lot = { workspace = true } rand = { workspace = true } rayon = { workspace = true } serde = { workspace = true } @@ -63,7 +64,7 @@ serde = { workspace = true } aptos-aggregator = { workspace = true, features = ["testing"] } aptos-block-executor = { workspace = true, features = ["testing"] } aptos-language-e2e-tests = { workspace = true } -aptos-types = { workspace = true, features = ["fuzzing"] } +aptos-types = { workspace = true, features = ["fuzzing", "testing"] } claims = { workspace = true } move-vm-types = { workspace = true, features = ["testing"] } proptest = { workspace = true } diff --git a/aptos-move/aptos-vm/src/aptos_vm.rs b/aptos-move/aptos-vm/src/aptos_vm.rs index 5b65381445967..03fb371b1601e 100644 --- a/aptos-move/aptos-vm/src/aptos_vm.rs +++ b/aptos-move/aptos-vm/src/aptos_vm.rs @@ -27,7 +27,9 @@ use crate::{ VMBlockExecutor, VMValidator, }; use anyhow::anyhow; -use aptos_block_executor::txn_commit_hook::NoOpTransactionCommitHook; +use aptos_block_executor::{ + code_cache_global_manager::ModuleCacheManager, txn_commit_hook::NoOpTransactionCommitHook, +}; use aptos_crypto::HashValue; use aptos_framework::{ natives::{code::PublishRequest, randomness::RandomnessContext}, @@ -43,7 +45,10 @@ use aptos_types::state_store::StateViewId; use aptos_types::{ account_config::{self, new_block_event_key, AccountResource}, block_executor::{ - config::{BlockExecutorConfig, BlockExecutorConfigFromOnchain, BlockExecutorLocalConfig}, + config::{ + BlockExecutorConfig, BlockExecutorConfigFromOnchain, BlockExecutorLocalConfig, + BlockExecutorModuleCacheLocalConfig, + }, partitioner::PartitionedTransactions, }, block_metadata::BlockMetadata, @@ -65,6 +70,7 @@ use aptos_types::{ TransactionAuxiliaryData, TransactionOutput, TransactionPayload, TransactionStatus, VMValidatorResult, ViewFunctionOutput, WriteSetPayload, }, + vm::modules::AptosModuleExtension, vm_status::{AbortLocation, StatusCode, VMStatus}, }; use aptos_utils::aptos_try; @@ -111,7 +117,7 @@ use move_vm_metrics::{Timer, VM_TIMER}; use move_vm_runtime::{ logging::expect_no_verification_errors, module_traversal::{TraversalContext, TraversalStorage}, - RuntimeEnvironment, WithRuntimeEnvironment, + Module, RuntimeEnvironment, WithRuntimeEnvironment, }; use move_vm_types::gas::{GasMeter, UnmeteredGasMeter}; use num_cpus; @@ -120,6 +126,7 @@ use std::{ cmp::{max, min}, collections::{BTreeMap, BTreeSet}, marker::Sync, + str::FromStr, sync::Arc, }; @@ -2773,29 +2780,27 @@ impl AptosVM { /// Transaction execution: AptosVM /// Executing conflicts: in the input order, via BlockSTM, /// State: BlockSTM-provided MVHashMap-based view with caching -pub struct AptosVMBlockExecutor; +pub struct AptosVMBlockExecutor { + /// Manages module cache and execution environment of this block executor. Users of executor + /// must use manager's API to ensure the correct state of caches. + module_cache_manager: + ModuleCacheManager, +} -// Executor external API impl VMBlockExecutor for AptosVMBlockExecutor { - // NOTE: At the moment there are no persistent caches that live past the end of a block (that's - // why AptosVMBlockExecutor has no state) - // There are some cache invalidation issues around transactions publishing code that need to be - // sorted out before that's possible. - fn new() -> Self { - Self + Self { + module_cache_manager: ModuleCacheManager::new(), + } } - /// Execute a block of `transactions`. The output vector will have the exact same length as the - /// input vector. The discarded transactions will be marked as `TransactionStatus::Discard` and - /// have an empty `WriteSet`. Also `state_view` is immutable, and does not have interior - /// mutability. Writes to be applied to the data view are encoded in the write set part of a - /// transaction output. fn execute_block( &self, transactions: &[SignatureVerifiedTransaction], state_view: &(impl StateView + Sync), onchain_config: BlockExecutorConfigFromOnchain, + parent_block: Option<&HashValue>, + current_block: Option, ) -> Result, VMStatus> { fail_point!("move_adapter::execute_block", |_| { Err(VMStatus::error( @@ -2811,20 +2816,27 @@ impl VMBlockExecutor for AptosVMBlockExecutor { ); let count = transactions.len(); + let concurrency_level = + usize::from_str(&std::env::var("CONCURRENCY_LEVEL").unwrap()).unwrap(); + let ret = BlockAptosVM::execute_block::< _, NoOpTransactionCommitHook, >( transactions, state_view, + &self.module_cache_manager, BlockExecutorConfig { local: BlockExecutorLocalConfig { - concurrency_level: AptosVM::get_concurrency_level(), + concurrency_level, allow_fallback: true, discard_failed_blocks: AptosVM::get_discard_failed_blocks(), + module_cache_config: BlockExecutorModuleCacheLocalConfig::default(), }, onchain: onchain_config, }, + parent_block, + current_block, None, ); if ret.is_ok() { diff --git a/aptos-move/aptos-vm/src/block_executor/mod.rs b/aptos-move/aptos-vm/src/block_executor/mod.rs index de16c676676b6..9336a90ba028b 100644 --- a/aptos-move/aptos-vm/src/block_executor/mod.rs +++ b/aptos-move/aptos-vm/src/block_executor/mod.rs @@ -12,11 +12,14 @@ use aptos_aggregator::{ delayed_change::DelayedChange, delta_change_set::DeltaOp, resolver::TAggregatorV1View, }; use aptos_block_executor::{ - code_cache_global::ImmutableModuleCache, errors::BlockExecutionError, executor::BlockExecutor, + code_cache_global::GlobalModuleCache, code_cache_global_manager::ModuleCacheManager, + errors::BlockExecutionError, executor::BlockExecutor, task::TransactionOutput as BlockExecutorTransactionOutput, txn_commit_hook::TransactionCommitHook, types::InputOutputKey, }; +use aptos_crypto::HashValue; use aptos_infallible::Mutex; +use aptos_logger::error; use aptos_types::{ block_executor::config::BlockExecutorConfig, contract_event::ContractEvent, @@ -32,24 +35,30 @@ use aptos_types::{ write_set::WriteOp, }; use aptos_vm_environment::environment::AptosEnvironment; -use aptos_vm_logging::{flush_speculative_logs, init_speculative_logs}; +use aptos_vm_logging::{ + alert, flush_speculative_logs, init_speculative_logs, prelude::CRITICAL_ERRORS, +}; use aptos_vm_types::{ - abstract_write_op::AbstractResourceWriteOp, module_write_set::ModuleWrite, output::VMOutput, + abstract_write_op::AbstractResourceWriteOp, + module_and_script_storage::{AptosCodeStorageAdapter, AsAptosCodeStorage}, + module_write_set::ModuleWrite, + output::VMOutput, resolver::ResourceGroupSize, }; -use move_binary_format::{errors::Location, CompiledModule}; +use move_binary_format::{errors::VMError, CompiledModule}; use move_core_types::{ + account_address::AccountAddress, + ident_str, language_storage::{ModuleId, StructTag}, value::MoveTypeLayout, vm_status::{StatusCode, VMStatus}, }; -use move_vm_runtime::{Module, WithRuntimeEnvironment}; +use move_vm_runtime::{Module, ModuleStorage}; use move_vm_types::delayed_values::delayed_field_id::DelayedFieldID; use once_cell::sync::{Lazy, OnceCell}; +use parking_lot::RwLock; use std::{ collections::{BTreeMap, HashSet}, - hash::Hash, - ops::Deref, sync::Arc, }; @@ -63,60 +72,6 @@ static RAYON_EXEC_POOL: Lazy> = Lazy::new(|| { ) }); -/// Immutable global module cache that can be shared across multiple block executions. The size of -/// the cache is fixed within a single block (modules are not inserted or removed) and it is only -/// mutated at the block boundaries. Do not use if multiple blocks are executed concurrently. -static GLOBAL_MODULE_CACHE: Lazy< - Arc>, -> = Lazy::new(|| Arc::new(ImmutableModuleCache::empty())); - -/// The maximum size of struct name index map in runtime environment. Checked at block boundaries -/// only. -const MAX_STRUCT_NAME_INDEX_MAP_SIZE: usize = 100_000; - -/// A cached environment that can be persisted globally across blocks. -static GLOBAL_ENVIRONMENT: Lazy>> = Lazy::new(|| Mutex::new(None)); - -/// Returns the cached environment if it exists and has the same configuration as if it was -/// created based on the current state, or creates a new one and caches it. Should only be -/// called at the block boundaries. -fn get_environment_with_delayed_field_optimization_enabled( - state_view: &impl StateView, - global_module_cache: &ImmutableModuleCache, -) -> Result -where - K: Hash + Eq + Clone, - VC: Deref>, -{ - // Create a new environment. - let current_env = AptosEnvironment::new_with_delayed_field_optimization_enabled(state_view); - - // Lock the cache, and check if the environment is the same. - let mut global_environment = GLOBAL_ENVIRONMENT.lock(); - if let Some(previous_env) = global_environment.as_ref() { - if ¤t_env == previous_env { - let runtime_env = previous_env.runtime_environment(); - let struct_name_index_map_size = runtime_env - .struct_name_index_map_size() - .map_err(|e| e.finish(Location::Undefined).into_vm_status())?; - if struct_name_index_map_size > MAX_STRUCT_NAME_INDEX_MAP_SIZE { - // Cache is too large, flush it. Also flush the module cache. - runtime_env.flush_struct_name_and_info_caches(); - global_module_cache.flush_unchecked(); - } - return Ok(previous_env.clone()); - } - } - - // It is not cached or has changed, so we have to reset it. As a result, we need to flush - // the cross-block cache because we need to reload all modules with new configs. - *global_environment = Some(current_env.clone()); - drop(global_environment); - global_module_cache.flush_unchecked(); - - Ok(current_env) -} - /// Output type wrapper used by block executor. VM output is stored first, then /// transformed into TransactionOutput type that is returned. #[derive(Debug)] @@ -448,20 +403,27 @@ impl BlockExecutorTransactionOutput for AptosTransactionOutput { pub struct BlockAptosVM; impl BlockAptosVM { - fn execute_block_on_thread_pool< + pub fn execute_block_on_thread_pool< S: StateView + Sync, L: TransactionCommitHook, >( executor_thread_pool: Arc, signature_verified_block: &[SignatureVerifiedTransaction], state_view: &S, - global_module_cache: Arc< - ImmutableModuleCache, + module_cache_manager: &ModuleCacheManager< + HashValue, + ModuleId, + CompiledModule, + Module, + AptosModuleExtension, >, config: BlockExecutorConfig, + parent_block: Option<&HashValue>, + current_block: Option, transaction_commit_listener: Option, ) -> Result, VMStatus> { let _timer = BLOCK_EXECUTOR_EXECUTE_BLOCK_SECONDS.start_timer(); + let num_txns = signature_verified_block.len(); if state_view.id() != StateViewId::Miscellaneous { // Speculation is disabled in Miscellaneous context, which is used by testing and @@ -471,10 +433,39 @@ impl BlockAptosVM { BLOCK_EXECUTOR_CONCURRENCY.set(config.local.concurrency_level as i64); - let environment = get_environment_with_delayed_field_optimization_enabled( - state_view, - global_module_cache.as_ref(), - )?; + let environment = + AptosEnvironment::new_with_delayed_field_optimization_enabled(&state_view); + let is_loader_v2_enabled = environment.features().is_loader_v2_enabled(); + + let (environment, module_cache) = if is_loader_v2_enabled { + if !module_cache_manager.mark_ready(parent_block, current_block) { + return Err(VMStatus::error( + StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR, + Some("Unable to mark module caches for block execution as ready".to_string()), + )); + } + module_cache_manager + .check_ready_and_get_caches(environment, &config.local.module_cache_config)? + } else { + ( + environment, + Arc::new(RwLock::new(GlobalModuleCache::empty())), + ) + }; + + // Finally, to avoid cold starts, fetch the framework code prior to block execution. This + // ensures the state with 0 modules cached is not possible for block execution (as long as + // the config enables the framework prefetch). + if is_loader_v2_enabled + && module_cache.read().num_modules() == 0 + && config.local.module_cache_config.prefetch_framework_code + { + let code_storage = state_view.as_aptos_code_storage(environment.clone()); + prefetch_aptos_framework(code_storage, &mut module_cache.write()).map_err(|err| { + alert!("Failed to load Aptos framework to module cache: {:?}", err); + VMError::from(err).into_vm_status() + })?; + } let executor = BlockExecutor::< SignatureVerifiedTransaction, @@ -482,14 +473,27 @@ impl BlockAptosVM { S, L, ExecutableTestType, - >::new( - config, - executor_thread_pool, - global_module_cache, - transaction_commit_listener, + >::new(config, executor_thread_pool, transaction_commit_listener); + + if is_loader_v2_enabled && !module_cache_manager.mark_executing() { + return Err(VMStatus::error( + StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR, + Some("Unable to mark block execution start".to_string()), + )); + } + let ret = executor.execute_block( + environment, + signature_verified_block, + state_view, + module_cache.as_ref(), ); + if is_loader_v2_enabled && !module_cache_manager.mark_done() { + return Err(VMStatus::error( + StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR, + Some("Unable to mark block execution as done".to_string()), + )); + } - let ret = executor.execute_block(environment, signature_verified_block, state_view); match ret { Ok(block_output) => { let (transaction_outputs, block_end_info) = block_output.into_inner(); @@ -520,87 +524,97 @@ impl BlockAptosVM { } } - pub fn execute_block_on_thread_pool_without_global_module_cache< - S: StateView + Sync, - L: TransactionCommitHook, - >( - executor_thread_pool: Arc, - signature_verified_block: &[SignatureVerifiedTransaction], - state_view: &S, - config: BlockExecutorConfig, - transaction_commit_listener: Option, - ) -> Result, VMStatus> { - Self::execute_block_on_thread_pool::( - executor_thread_pool, - signature_verified_block, - state_view, - Arc::new(ImmutableModuleCache::empty()), - config, - transaction_commit_listener, - ) - } - - /// Uses shared thread pool and shared global module cache to execute blocks. + /// Uses shared thread pool to execute blocks. pub fn execute_block< S: StateView + Sync, L: TransactionCommitHook, >( signature_verified_block: &[SignatureVerifiedTransaction], state_view: &S, + module_cache_manager: &ModuleCacheManager< + HashValue, + ModuleId, + CompiledModule, + Module, + AptosModuleExtension, + >, config: BlockExecutorConfig, + parent_block: Option<&HashValue>, + current_block: Option, transaction_commit_listener: Option, ) -> Result, VMStatus> { Self::execute_block_on_thread_pool::( Arc::clone(&RAYON_EXEC_POOL), signature_verified_block, state_view, - Arc::clone(&GLOBAL_MODULE_CACHE), + module_cache_manager, config, + parent_block, + current_block, transaction_commit_listener, ) } } +/// If Aptos framework exists, loads "transaction_validation.move" and all its transitive +/// dependencies from storage into provided module cache. If loading fails for any reason, a panic +/// error is returned. +fn prefetch_aptos_framework( + code_storage: AptosCodeStorageAdapter, + module_cache: &mut GlobalModuleCache, +) -> Result<(), PanicError> { + // If framework code exists in storage, the transitive closure will be verified and cached. + let maybe_loaded = code_storage + .fetch_verified_module(&AccountAddress::ONE, ident_str!("transaction_validation")) + .map_err(|err| { + // There should be no errors when pre-fetching the framework, if there are, we + // better return an error here. + PanicError::CodeInvariantError(format!("Unable to fetch Aptos framework: {:?}", err)) + })?; + + if maybe_loaded.is_some() { + // Framework must have been loaded. Drain verified modules from local cache into + // global cache. + let verified_module_code_iter = code_storage.into_verified_module_code_iter()?; + module_cache.insert_verified_unsync(verified_module_code_iter)?; + } + Ok(()) +} + #[cfg(test)] mod test { use super::*; - use aptos_block_executor::code_cache_global::ImmutableModuleCache; - use aptos_language_e2e_tests::data_store::FakeDataStore; - use aptos_types::on_chain_config::{FeatureFlag, Features}; - use aptos_vm_environment::environment::AptosEnvironment; - use claims::assert_ok; - use move_vm_types::code::mock_verified_code; + use aptos_language_e2e_tests::{data_store::FakeDataStore, executor::FakeExecutor}; #[test] - fn test_cross_block_module_cache_flush() { - let global_module_cache = ImmutableModuleCache::empty(); + fn test_prefetch_existing_aptos_framework() { + let executor = FakeExecutor::from_head_genesis(); + let state_view = executor.get_state_view(); - global_module_cache.insert(0, mock_verified_code(0, None)); - assert_eq!(global_module_cache.size(), 1); + let environment = AptosEnvironment::new_with_delayed_field_optimization_enabled(state_view); + let code_storage = state_view.as_aptos_code_storage(environment); - global_module_cache.flush_unchecked(); - assert_eq!(global_module_cache.size(), 0); + let mut module_cache = GlobalModuleCache::empty(); + assert_eq!(module_cache.num_modules(), 0); - // Now check that cache is flushed when the environment is flushed. - let mut state_view = FakeDataStore::default(); - let env_old = AptosEnvironment::new_with_delayed_field_optimization_enabled(&state_view); + let result = prefetch_aptos_framework(code_storage, &mut module_cache); + assert!(result.is_ok()); + assert!(module_cache.num_modules() > 0); + } - for i in 0..10 { - global_module_cache.insert(i, mock_verified_code(i, None)); - } - assert_eq!(global_module_cache.size(), 10); - - let mut features = Features::default(); - features.disable(FeatureFlag::KEYLESS_ACCOUNTS); - state_view.set_features(features); - - // New environment means we need to also flush global caches - to invalidate struct name - // indices. - let env_new = assert_ok!(get_environment_with_delayed_field_optimization_enabled( - &state_view, - &global_module_cache, - )); - assert!(env_old != env_new); - assert_eq!(global_module_cache.size(), 0); + #[test] + fn test_prefetch_non_existing_aptos_framework() { + let state_view = FakeDataStore::default(); + + let environment = + AptosEnvironment::new_with_delayed_field_optimization_enabled(&state_view); + let code_storage = state_view.as_aptos_code_storage(environment); + + let mut module_cache = GlobalModuleCache::empty(); + assert_eq!(module_cache.num_modules(), 0); + + let result = prefetch_aptos_framework(code_storage, &mut module_cache); + assert!(result.is_ok()); + assert_eq!(module_cache.num_modules(), 0); } } diff --git a/aptos-move/aptos-vm/src/lib.rs b/aptos-move/aptos-vm/src/lib.rs index 56e876ee4b887..3f21e37f8e2b1 100644 --- a/aptos-move/aptos-vm/src/lib.rs +++ b/aptos-move/aptos-vm/src/lib.rs @@ -126,6 +126,7 @@ pub mod verifier; pub use crate::aptos_vm::{AptosSimulationVM, AptosVM}; use crate::sharded_block_executor::{executor_client::ExecutorClient, ShardedBlockExecutor}; +use aptos_crypto::HashValue; use aptos_types::{ block_executor::{ config::BlockExecutorConfigFromOnchain, partitioner::PartitionedTransactions, @@ -152,11 +153,16 @@ pub trait VMValidator { ) -> VMValidatorResult; } -/// This trait describes the VM's execution interface. +/// This trait describes the block executor interface which is responsible for executing a block of +/// transactions. In general, block execution returns a vector of transaction outputs. This vector +/// has the same length as the input vector of transactions. In case transactions are skipped or +/// discarded, they are still included - but their output is empty. The outputs are not applied to +/// the state directly. It is the responsibility of the caller to update the state accordingly. pub trait VMBlockExecutor: Send + Sync { - /// Be careful if any state is kept in VMBlockExecutor, as all validations are implementers responsibility - /// (and state_view passed in execute_block can go both backwards and forwards in time). - /// TODO: Currently, production uses new() on every block, and only executor-benchmark reuses across. + /// Be careful if any state (such as caches) is kept in [VMBlockExecutor]. It is the + /// responsibility of the implementation to ensure the state is valid across multiple + /// executions. For example, the same executor may be used to run on a new state, and then on + /// an old one. fn new() -> Self; /// Executes a block of transactions and returns output for each one of them. @@ -165,10 +171,12 @@ pub trait VMBlockExecutor: Send + Sync { transactions: &[SignatureVerifiedTransaction], state_view: &(impl StateView + Sync), onchain_config: BlockExecutorConfigFromOnchain, + parent_block: Option<&HashValue>, + current_block: Option, ) -> Result, VMStatus>; - /// Executes a block of transactions and returns output for each one of them, - /// Without applying any block limit + /// Executes a block of transactions and returns output for each one of them, without applying + /// any block limit. fn execute_block_no_limit( &self, transactions: &[SignatureVerifiedTransaction], @@ -178,6 +186,9 @@ pub trait VMBlockExecutor: Send + Sync { transactions, state_view, BlockExecutorConfigFromOnchain::new_no_block_limit(), + // For all use cases, we run on an unknown state. Hence, defaulting to None here. + None, + None, ) .map(BlockOutput::into_transaction_outputs_forced) } diff --git a/aptos-move/aptos-vm/src/move_vm_ext/vm.rs b/aptos-move/aptos-vm/src/move_vm_ext/vm.rs index a5eb957339e5a..5218435cafe58 100644 --- a/aptos-move/aptos-vm/src/move_vm_ext/vm.rs +++ b/aptos-move/aptos-vm/src/move_vm_ext/vm.rs @@ -7,7 +7,7 @@ use aptos_gas_schedule::{MiscGasParameters, NativeGasParameters, LATEST_GAS_FEAT use aptos_native_interface::SafeNativeBuilder; use aptos_types::{ chain_id::ChainId, - on_chain_config::{Features, TimedFeaturesBuilder}, + on_chain_config::{FeatureFlag, Features, TimedFeaturesBuilder}, transaction::user_transaction_context::UserTransactionContext, }; use aptos_vm_environment::{ @@ -30,7 +30,13 @@ pub struct GenesisRuntimeBuilder { impl GenesisRuntimeBuilder { /// Returns a builder, capable of creating VM and runtime environment to run genesis. pub fn new(chain_id: ChainId) -> Self { - let features = Features::default(); + let mut features = Features::default(); + if std::env::var("USE_LOADER_V2").is_ok() { + features.enable(FeatureFlag::ENABLE_LOADER_V2); + } else { + features.disable(FeatureFlag::ENABLE_LOADER_V2); + } + let timed_features = TimedFeaturesBuilder::enable_all().build(); let vm_config = diff --git a/aptos-move/aptos-vm/src/move_vm_ext/write_op_converter.rs b/aptos-move/aptos-vm/src/move_vm_ext/write_op_converter.rs index 1d54be49fe16f..56b1a33161d62 100644 --- a/aptos-move/aptos-vm/src/move_vm_ext/write_op_converter.rs +++ b/aptos-move/aptos-vm/src/move_vm_ext/write_op_converter.rs @@ -282,10 +282,7 @@ mod tests { }; use aptos_types::{ account_address::AccountAddress, - state_store::{ - errors::StateviewError, state_storage_usage::StateStorageUsage, - state_value::StateValue, TStateView, - }, + state_store::{state_value::StateValue, MockStateView}, write_set::TransactionWrite, }; use aptos_vm_environment::environment::AptosEnvironment; @@ -301,6 +298,7 @@ mod tests { identifier::Identifier, language_storage::{StructTag, TypeTag}, }; + use std::collections::HashMap; fn raw_metadata(v: u64) -> StateValueMetadata { StateValueMetadata::legacy(v, &CurrentTimeMicroseconds { microseconds: v }) @@ -334,31 +332,6 @@ mod tests { } } - struct MockStateView { - data: BTreeMap, - } - - impl MockStateView { - fn new(data: BTreeMap) -> Self { - Self { data } - } - } - - impl TStateView for MockStateView { - type Key = StateKey; - - fn get_state_value( - &self, - state_key: &Self::Key, - ) -> Result, StateviewError> { - Ok(self.data.get(state_key).cloned()) - } - - fn get_usage(&self) -> Result { - unimplemented!(); - } - } - fn module(name: &str) -> (StateKey, Bytes, CompiledModule) { let module = empty_module_with_dependencies_and_friends(name, vec![], vec![]); let state_key = StateKey::module(module.self_addr(), module.self_name()); @@ -400,7 +373,7 @@ mod tests { let state_value = StateValue::new_legacy(bytes.into()); // Setting up the state. - let state_view = MockStateView::new(BTreeMap::from([ + let state_view = MockStateView::new(HashMap::from([ (state_key, state_value), (a_state_key.clone(), a_state_value.clone()), (b_state_key.clone(), b_state_value.clone()), @@ -472,7 +445,7 @@ mod tests { let metadata = raw_metadata(100); let key = StateKey::raw(&[0]); - let data = BTreeMap::from([( + let data = HashMap::from([( key.clone(), StateValue::new_with_metadata(bcs::to_bytes(&group).unwrap().into(), metadata.clone()), )]); @@ -528,7 +501,7 @@ mod tests { let metadata = raw_metadata(100); let key = StateKey::raw(&[0]); - let data = BTreeMap::from([( + let data = HashMap::from([( key.clone(), StateValue::new_with_metadata(bcs::to_bytes(&group).unwrap().into(), metadata.clone()), )]); @@ -562,7 +535,7 @@ mod tests { // #[test] #[allow(unused)] fn size_computation_new_group() { - let s = MockStateView::new(BTreeMap::new()); + let s = MockStateView::empty(); let resolver = as_resolver_with_group_size_kind(&s, GroupSizeKind::AsSum); // TODO[agg_v2](test): Layout hardcoded to None. Test with layout = Some(..) @@ -595,7 +568,7 @@ mod tests { let metadata = raw_metadata(100); let key = StateKey::raw(&[0]); - let data = BTreeMap::from([( + let data = HashMap::from([( key.clone(), StateValue::new_with_metadata(bcs::to_bytes(&group).unwrap().into(), metadata.clone()), )]); diff --git a/aptos-move/aptos-vm/src/sharded_block_executor/global_executor.rs b/aptos-move/aptos-vm/src/sharded_block_executor/global_executor.rs index 90a12556deb57..239bbaba7bb24 100644 --- a/aptos-move/aptos-vm/src/sharded_block_executor/global_executor.rs +++ b/aptos-move/aptos-vm/src/sharded_block_executor/global_executor.rs @@ -60,11 +60,9 @@ impl GlobalExecutor { GLOBAL_ROUND_ID, state_view, BlockExecutorConfig { - local: BlockExecutorLocalConfig { - concurrency_level: self.concurrency_level, - allow_fallback: true, - discard_failed_blocks: false, - }, + local: BlockExecutorLocalConfig::default_with_concurrency_level( + self.concurrency_level, + ), onchain: onchain_config, }, ) diff --git a/aptos-move/aptos-vm/src/sharded_block_executor/sharded_executor_service.rs b/aptos-move/aptos-vm/src/sharded_block_executor/sharded_executor_service.rs index efe860c37103e..4c52ba947339f 100644 --- a/aptos-move/aptos-vm/src/sharded_block_executor/sharded_executor_service.rs +++ b/aptos-move/aptos-vm/src/sharded_block_executor/sharded_executor_service.rs @@ -16,6 +16,7 @@ use crate::{ ExecutorShardCommand, }, }; +use aptos_block_executor::code_cache_global_manager::ModuleCacheManager; use aptos_logger::{info, trace}; use aptos_types::{ block_executor::{ @@ -135,11 +136,16 @@ impl ShardedExecutorService { ); }); s.spawn(move |_| { - let ret = BlockAptosVM::execute_block_on_thread_pool_without_global_module_cache( + let ret = BlockAptosVM::execute_block_on_thread_pool( executor_thread_pool, &signature_verified_transactions, aggr_overridden_state_view.as_ref(), + // Since we execute blocks in parallel, we cannot share module caches, so each + // thread has its own caches. + &ModuleCacheManager::new(), config, + None, + None, cross_shard_commit_sender, ) .map(BlockOutput::into_transaction_outputs_forced); @@ -230,11 +236,9 @@ impl ShardedExecutorService { transactions, state_view.as_ref(), BlockExecutorConfig { - local: BlockExecutorLocalConfig { - concurrency_level: concurrency_level_per_shard, - allow_fallback: true, - discard_failed_blocks: false, - }, + local: BlockExecutorLocalConfig::default_with_concurrency_level( + concurrency_level_per_shard, + ), onchain: onchain_config, }, ); diff --git a/aptos-move/block-executor/Cargo.toml b/aptos-move/block-executor/Cargo.toml index aefd0ae6f13cc..a1aefe7441e45 100644 --- a/aptos-move/block-executor/Cargo.toml +++ b/aptos-move/block-executor/Cargo.toml @@ -22,6 +22,7 @@ aptos-logger = { workspace = true } aptos-metrics-core = { workspace = true } aptos-mvhashmap = { workspace = true } aptos-types = { workspace = true } +aptos-vm-environment = { workspace = true } aptos-vm-logging = { workspace = true } aptos-vm-types = { workspace = true } arc-swap = { workspace = true } @@ -54,6 +55,7 @@ aptos-types = { workspace = true, features = ["testing"] } criterion = { workspace = true } fail = { workspace = true, features = ["failpoints"] } itertools = { workspace = true } +move-vm-runtime = { workspace = true, features = ["testing"] } move-vm-types = { workspace = true, features = ["testing"] } proptest = { workspace = true } proptest-derive = { workspace = true } diff --git a/aptos-move/block-executor/src/captured_reads.rs b/aptos-move/block-executor/src/captured_reads.rs index 007ae211b9d2c..516b0855c39c4 100644 --- a/aptos-move/block-executor/src/captured_reads.rs +++ b/aptos-move/block-executor/src/captured_reads.rs @@ -2,7 +2,7 @@ // SPDX-License-Identifier: Apache-2.0 use crate::{ - code_cache_global::ImmutableModuleCache, types::InputOutputKey, + code_cache_global::GlobalModuleCache, types::InputOutputKey, value_exchange::filter_value_for_exchange, }; use anyhow::bail; @@ -29,7 +29,7 @@ use aptos_types::{ use aptos_vm_types::resolver::ResourceGroupSize; use derivative::Derivative; use move_core_types::value::MoveTypeLayout; -use move_vm_types::code::{ModuleCode, SyncModuleCache, WithAddress, WithName}; +use move_vm_types::code::{ModuleCode, SyncModuleCache, WithAddress, WithName, WithSize}; use std::{ collections::{ hash_map::{ @@ -299,7 +299,7 @@ enum ModuleRead { /// Read from the cross-block module cache. GlobalCache, /// Read from per-block cache ([SyncCodeCache]) used by parallel execution. - PerBlockCache(Option>>>), + PerBlockCache(Option<(Arc>, Option)>), } /// Represents a result of a read from [CapturedReads] when they are used as the transaction-level @@ -353,6 +353,7 @@ where T: Transaction, K: Hash + Eq + Ord + Clone, VC: Deref>, + S: WithSize, { // Return an iterator over the captured reads. pub(crate) fn get_read_values_with_delayed_fields( @@ -622,7 +623,7 @@ where pub(crate) fn capture_per_block_cache_read( &mut self, key: K, - read: Option>>>, + read: Option<(Arc>, Option)>, ) { self.module_reads .insert(key, ModuleRead::PerBlockCache(read)); @@ -634,7 +635,7 @@ where pub(crate) fn get_module_read( &self, key: &K, - ) -> Result>>>>, PanicError> { + ) -> Result>, Option)>>, PanicError> { Ok(match self.module_reads.get(key) { Some(ModuleRead::PerBlockCache(read)) => CacheRead::Hit(read.clone()), Some(ModuleRead::GlobalCache) => { @@ -652,7 +653,7 @@ where /// 3. Entries that were in per-block cache have the same commit index. pub(crate) fn validate_module_reads( &self, - global_module_cache: &ImmutableModuleCache, + global_module_cache: &GlobalModuleCache, per_block_module_cache: &SyncModuleCache>, ) -> bool { if self.non_delayed_field_speculative_failure { @@ -663,7 +664,7 @@ where ModuleRead::GlobalCache => global_module_cache.contains_valid(key), ModuleRead::PerBlockCache(previous) => { let current_version = per_block_module_cache.get_module_version(key); - let previous_version = previous.as_ref().map(|module| module.version()); + let previous_version = previous.as_ref().map(|(_, version)| *version); current_version == previous_version }, }) @@ -873,7 +874,10 @@ where #[cfg(test)] mod test { use super::*; - use crate::proptest_types::types::{raw_metadata, KeyType, MockEvent, ValueType}; + use crate::{ + code_cache_global::GlobalModuleCache, + proptest_types::types::{raw_metadata, KeyType, MockEvent, ValueType}, + }; use aptos_mvhashmap::{types::StorageVersion, MVHashMap}; use aptos_types::executable::ExecutableTestType; use claims::{ @@ -881,8 +885,8 @@ mod test { }; use move_vm_types::{ code::{ - mock_deserialized_code, mock_verified_code, MockDeserializedCode, MockVerifiedCode, - ModuleCache, + mock_deserialized_code, mock_verified_code, MockDeserializedCode, MockExtension, + MockVerifiedCode, ModuleCache, }, delayed_values::delayed_field_id::DelayedFieldID, }; @@ -1077,7 +1081,13 @@ mod test { ($m:expr, $x:expr, $y:expr) => {{ let original = $m.get(&$x).cloned().unwrap(); assert_matches!( - CapturedReads::::update_entry($m.entry($x), $y.clone()), + CapturedReads::< + TestTransactionType, + u32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::update_entry($m.entry($x), $y.clone()), UpdateResult::IncorrectUse(_) ); assert_some_eq!($m.get(&$x), &original); @@ -1088,7 +1098,13 @@ mod test { ($m:expr, $x:expr, $y:expr) => {{ let original = $m.get(&$x).cloned().unwrap(); assert_matches!( - CapturedReads::::update_entry($m.entry($x), $y.clone()), + CapturedReads::< + TestTransactionType, + u32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::update_entry($m.entry($x), $y.clone()), UpdateResult::Inconsistency(_) ); assert_some_eq!($m.get(&$x), &original); @@ -1098,7 +1114,13 @@ mod test { macro_rules! assert_update { ($m:expr, $x:expr, $y:expr) => {{ assert_matches!( - CapturedReads::::update_entry($m.entry($x), $y.clone()), + CapturedReads::< + TestTransactionType, + u32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::update_entry($m.entry($x), $y.clone()), UpdateResult::Updated ); assert_some_eq!($m.get(&$x), &$y); @@ -1108,7 +1130,13 @@ mod test { macro_rules! assert_insert { ($m:expr, $x:expr, $y:expr) => {{ assert_matches!( - CapturedReads::::update_entry($m.entry($x), $y.clone()), + CapturedReads::< + TestTransactionType, + u32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::update_entry($m.entry($x), $y.clone()), UpdateResult::Inserted ); assert_some_eq!($m.get(&$x), &$y); @@ -1280,7 +1308,7 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - u32, + MockExtension, >::new(); let legacy_reads = legacy_reads_by_kind(); let deletion_reads = deletion_reads_by_kind(); @@ -1314,7 +1342,7 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - u32, + MockExtension, >::new(); captured_reads.get_by_kind(&KeyType::(21, false), Some(&10), ReadKind::Metadata); } @@ -1342,7 +1370,7 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - (), + MockExtension, >::new(); let legacy_reads = legacy_reads_by_kind(); let deletion_reads = deletion_reads_by_kind(); @@ -1404,7 +1432,7 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - (), + MockExtension, >::new(); let versioned_legacy = DataRead::Versioned( Err(StorageVersion), @@ -1461,7 +1489,7 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - (), + MockExtension, >::new(); captured_reads.non_delayed_field_speculative_failure = false; captured_reads.delayed_field_speculative_failure = false; @@ -1495,9 +1523,9 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - (), + MockExtension, >::new(); - let global_module_cache = ImmutableModuleCache::empty(); + let global_module_cache = GlobalModuleCache::empty(); let per_block_module_cache = SyncModuleCache::empty(); assert!(captured_reads.validate_module_reads(&global_module_cache, &per_block_module_cache)); @@ -1516,7 +1544,7 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - (), + MockExtension, >::new(); captured_reads.capture_global_cache_read(0); @@ -1530,32 +1558,32 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - (), + MockExtension, >::new(); - let global_module_cache = ImmutableModuleCache::empty(); + let mut global_module_cache = GlobalModuleCache::empty(); let per_block_module_cache = SyncModuleCache::empty(); - global_module_cache.insert(0, mock_verified_code(0, None)); + global_module_cache.insert(0, mock_verified_code(0, MockExtension::new(8))); captured_reads.capture_global_cache_read(0); - global_module_cache.insert(1, mock_verified_code(1, None)); + global_module_cache.insert(1, mock_verified_code(1, MockExtension::new(8))); captured_reads.capture_global_cache_read(1); assert!(captured_reads.validate_module_reads(&global_module_cache, &per_block_module_cache)); // Now, mark one of the entries in invalid. Validations should fail! - global_module_cache.mark_invalid(&1); + global_module_cache.mark_invalid_if_contains(&1); let valid = captured_reads.validate_module_reads(&global_module_cache, &per_block_module_cache); assert!(!valid); // Without invalid module (and if it is not captured), validation should pass. - global_module_cache.remove(&1); + assert!(global_module_cache.remove(&1)); captured_reads.module_reads.remove(&1); assert!(captured_reads.validate_module_reads(&global_module_cache, &per_block_module_cache)); // Validation fails if we captured a cross-block module which does not exist anymore. - global_module_cache.remove(&0); + assert!(global_module_cache.remove(&0)); let valid = captured_reads.validate_module_reads(&global_module_cache, &per_block_module_cache); assert!(!valid); @@ -1568,21 +1596,21 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - (), + MockExtension, >::new(); let per_block_module_cache: SyncModuleCache = SyncModuleCache::empty(); - let a = mock_deserialized_code(0, Some(2)); + let a = mock_deserialized_code(0, MockExtension::new(8)); per_block_module_cache .insert_deserialized_module( 0, a.code().deserialized().as_ref().clone(), a.extension().clone(), - a.version(), + Some(2), ) .unwrap(); - captured_reads.capture_per_block_cache_read(0, Some(a)); + captured_reads.capture_per_block_cache_read(0, Some((a, Some(2)))); assert!(matches!( captured_reads.get_module_read(&0), Ok(CacheRead::Hit(Some(_))) @@ -1607,32 +1635,32 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - (), + MockExtension, >::new(); - let global_module_cache = ImmutableModuleCache::empty(); + let global_module_cache = GlobalModuleCache::empty(); let per_block_module_cache = SyncModuleCache::empty(); - let a = mock_deserialized_code(0, Some(10)); + let a = mock_deserialized_code(0, MockExtension::new(8)); per_block_module_cache .insert_deserialized_module( 0, a.code().deserialized().as_ref().clone(), a.extension().clone(), - a.version(), + Some(10), ) .unwrap(); - captured_reads.capture_per_block_cache_read(0, Some(a)); + captured_reads.capture_per_block_cache_read(0, Some((a, Some(10)))); captured_reads.capture_per_block_cache_read(1, None); assert!(captured_reads.validate_module_reads(&global_module_cache, &per_block_module_cache)); - let b = mock_deserialized_code(1, Some(12)); + let b = mock_deserialized_code(1, MockExtension::new(8)); per_block_module_cache .insert_deserialized_module( 1, b.code().deserialized().as_ref().clone(), b.extension().clone(), - b.version(), + Some(12), ) .unwrap(); @@ -1645,13 +1673,13 @@ mod test { assert!(captured_reads.validate_module_reads(&global_module_cache, &per_block_module_cache)); // Version has been republished, with a higher transaction index. Should fail validation. - let a = mock_deserialized_code(0, Some(20)); + let a = mock_deserialized_code(0, MockExtension::new(8)); per_block_module_cache .insert_deserialized_module( 0, a.code().deserialized().as_ref().clone(), a.extension().clone(), - a.version(), + Some(20), ) .unwrap(); @@ -1667,25 +1695,25 @@ mod test { u32, MockDeserializedCode, MockVerifiedCode, - (), + MockExtension, >::new(); - let global_module_cache = ImmutableModuleCache::empty(); + let mut global_module_cache = GlobalModuleCache::empty(); let per_block_module_cache = SyncModuleCache::empty(); // Module exists in global cache. - global_module_cache.insert(0, mock_verified_code(0, None)); + global_module_cache.insert(0, mock_verified_code(0, MockExtension::new(8))); captured_reads.capture_global_cache_read(0); assert!(captured_reads.validate_module_reads(&global_module_cache, &per_block_module_cache)); // Assume we republish this module: validation must fail. - let a = mock_deserialized_code(100, Some(10)); - global_module_cache.mark_invalid(&0); + let a = mock_deserialized_code(100, MockExtension::new(8)); + global_module_cache.mark_invalid_if_contains(&0); per_block_module_cache .insert_deserialized_module( 0, a.code().deserialized().as_ref().clone(), a.extension().clone(), - a.version(), + Some(10), ) .unwrap(); @@ -1694,7 +1722,7 @@ mod test { assert!(!valid); // Assume we re-read the new correct version. Then validation should pass again. - captured_reads.capture_per_block_cache_read(0, Some(a)); + captured_reads.capture_per_block_cache_read(0, Some((a, Some(10)))); assert!(captured_reads.validate_module_reads(&global_module_cache, &per_block_module_cache)); assert!(!global_module_cache.contains_valid(&0)); } diff --git a/aptos-move/block-executor/src/code_cache.rs b/aptos-move/block-executor/src/code_cache.rs index 5f4864621b1f1..d9b236346dfe2 100644 --- a/aptos-move/block-executor/src/code_cache.rs +++ b/aptos-move/block-executor/src/code_cache.rs @@ -44,28 +44,22 @@ impl<'a, T: Transaction, S: TStateView, X: Executable> ModuleCodeB type Extension = AptosModuleExtension; type Key = ModuleId; type Verified = Module; - type Version = Option; fn build( &self, key: &Self::Key, - ) -> VMResult< - Option>, - > { + ) -> VMResult>> { let key = T::Key::from_address_and_module_name(key.address(), key.name()); self.get_raw_base_value(&key) .map_err(|err| err.finish(Location::Undefined))? .map(|state_value| { - let extension = AptosModuleExtension::new(state_value); + let extension = Arc::new(AptosModuleExtension::new(state_value)); + + // TODO(loader_v2): This recomputes module hash twice, we should avoid it. let (compiled_module, _, _) = self .runtime_environment() .deserialize_into_compiled_module(extension.bytes())?; - let version = None; - Ok(ModuleCode::from_deserialized( - compiled_module, - Arc::new(extension), - version, - )) + Ok(ModuleCode::from_deserialized(compiled_module, extension)) }) .transpose() } @@ -101,8 +95,7 @@ impl<'a, T: Transaction, S: TStateView, X: Executable> ModuleCache verified_code: Self::Verified, extension: Arc, version: Self::Version, - ) -> VMResult>> - { + ) -> VMResult>> { match &self.latest_view { ViewState::Sync(state) => { // For parallel execution, if we insert a verified module, we might need to also @@ -118,7 +111,7 @@ impl<'a, T: Transaction, S: TStateView, X: Executable> ModuleCache state .captured_reads .borrow_mut() - .capture_per_block_cache_read(key, Some(module.clone())); + .capture_per_block_cache_read(key, Some((module.clone(), version))); Ok(module) }, ViewState::Unsync(state) => state.unsync_map.module_cache().insert_verified_module( @@ -138,14 +131,16 @@ impl<'a, T: Transaction, S: TStateView, X: Executable> ModuleCache Deserialized = Self::Deserialized, Verified = Self::Verified, Extension = Self::Extension, - Version = Self::Version, >, ) -> VMResult< - Option>>, + Option<( + Arc>, + Self::Version, + )>, > { // First, look up the module in the cross-block global module cache. Record the read for // later validation in case the read module is republished. - if let Some(module) = self.global_module_cache.get(key) { + if let Some(module) = self.global_module_cache.get_valid(key) { match &self.latest_view { ViewState::Sync(state) => state .captured_reads @@ -155,7 +150,7 @@ impl<'a, T: Transaction, S: TStateView, X: Executable> ModuleCache state.read_set.borrow_mut().capture_module_read(key.clone()) }, } - return Ok(Some(module.clone())); + return Ok(Some((module, Self::Version::default()))); } // Global cache miss: check module cache in versioned/unsync maps. @@ -208,7 +203,7 @@ impl<'a, T: Transaction, S: TStateView, X: Executable> AptosModule let state_value_metadata = self .get_module_or_build_with(&id, self) .map_err(|err| err.to_partial())? - .map(|module| module.extension().state_value_metadata().clone()); + .map(|(module, _)| module.extension().state_value_metadata().clone()); Ok(state_value_metadata) } } diff --git a/aptos-move/block-executor/src/code_cache_global.rs b/aptos-move/block-executor/src/code_cache_global.rs index 6ff31da656e79..3f68f24fe4239 100644 --- a/aptos-move/block-executor/src/code_cache_global.rs +++ b/aptos-move/block-executor/src/code_cache_global.rs @@ -1,12 +1,9 @@ // Copyright © Aptos Foundation // SPDX-License-Identifier: Apache-2.0 -use crate::explicit_sync_wrapper::ExplicitSyncWrapper; -use aptos_mvhashmap::types::TxnIndex; use aptos_types::error::PanicError; -use crossbeam::utils::CachePadded; use hashbrown::HashMap; -use move_vm_types::code::ModuleCode; +use move_vm_types::code::{ModuleCode, WithSize}; use std::{ hash::Hash, ops::Deref, @@ -16,41 +13,32 @@ use std::{ }, }; -/// Module code stored in cross-block module cache. -// TODO(loader_v2): -// We can move this to move-vm-types, but then we also need to have version generic or expose -// transaction index there, and define PanicError in Move (or convert from VMError). -struct ImmutableModuleCode { - /// True if this code is "valid" within the block execution context (i.e, there has been no +/// Entry stored in [GlobalModuleCache]. +struct Entry { + /// True if this code is "valid" within the block execution context (i.e., there has been no /// republishing of this module so far). If false, executor needs to read the module from the /// sync/unsync module caches. - valid: CachePadded, - /// Cached verified module. While [ModuleCode] type is used, the following invariants always - /// hold: - /// 1. Module's version is [None] (storage version). - /// 2. Module's code is always verified. - module: CachePadded>>>, + valid: AtomicBool, + /// Cached verified module. Must always be verified. + module: Arc>, } -impl ImmutableModuleCode +impl Entry where - VC: Deref>, + Verified: Deref>, + Extension: WithSize, { - /// Returns a new valid module. Returns a (panic) error if the module is not verified or has - /// non-storage version. - fn new(module: Arc>>) -> Result { - if !module.code().is_verified() || module.version().is_some() { - let msg = format!( - "Invariant violated for immutable module code : verified ({}), version({:?})", - module.code().is_verified(), - module.version() - ); - return Err(PanicError::CodeInvariantError(msg)); + /// Returns a new valid module. Returns a (panic) error if the module is not verified. + fn new(module: Arc>) -> Result { + if !module.code().is_verified() { + return Err(PanicError::CodeInvariantError( + "Module code is not verified".to_string(), + )); } Ok(Self { - valid: CachePadded::new(AtomicBool::new(true)), - module: CachePadded::new(module), + valid: AtomicBool::new(true), + module, }) } @@ -64,227 +52,250 @@ where self.valid.load(Ordering::Acquire) } - /// Returns the module code stored is this [ImmutableModuleCode]. - fn inner(&self) -> &Arc>> { - self.module.deref() + /// Returns the module code stored is this [Entry]. + fn module_code(&self) -> &Arc> { + &self.module } } -/// An immutable cache for verified code, that can be accessed concurrently thought the block, and -/// only modified at block boundaries. -pub struct ImmutableModuleCache { +/// A global module cache for verified code that is read-only and concurrently accessed during the +/// block execution. Modified safely only at block boundaries. +pub struct GlobalModuleCache { /// Module cache containing the verified code. - module_cache: ExplicitSyncWrapper>>, - /// Maximum cache size. If the size is greater than this limit, the cache is flushed. Note that - /// this can only be done at block boundaries. - capacity: usize, + module_cache: HashMap>, + /// Sum of serialized sizes (in bytes) of all cached modules. + size: usize, } -impl ImmutableModuleCache +impl GlobalModuleCache where K: Hash + Eq + Clone, - VC: Deref>, + V: Deref>, + E: WithSize, { - /// Returns new empty module cache with default capacity. + /// Returns new empty module cache. pub fn empty() -> Self { - let default_capacity = 100_000; - Self::with_capacity(default_capacity) - } - - /// Returns new empty module cache with specified capacity. - fn with_capacity(capacity: usize) -> Self { Self { - module_cache: ExplicitSyncWrapper::new(HashMap::new()), - capacity, + module_cache: HashMap::new(), + size: 0, } } - /// Returns true if the key exists in immutable cache and the corresponding module is valid. - pub(crate) fn contains_valid(&self, key: &K) -> bool { + /// Returns true if the key exists in cache and the corresponding module is valid. + pub fn contains_valid(&self, key: &K) -> bool { self.module_cache - .acquire() .get(key) - .is_some_and(|module| module.is_valid()) + .is_some_and(|entry| entry.is_valid()) } /// Marks the cached module (if it exists) as invalid. As a result, all subsequent calls to the - /// cache for the associated key will result in a cache miss. Note that it is fine for an - /// entry not to exist, in which case this is a no-op. - pub(crate) fn mark_invalid(&self, key: &K) { - if let Some(module) = self.module_cache.acquire().get(key) { - module.mark_invalid(); + /// cache for the associated key will result in a cache miss. If an entry does not to exist, it + /// is a no-op. + pub fn mark_invalid_if_contains(&self, key: &K) { + if let Some(entry) = self.module_cache.get(key) { + entry.mark_invalid(); } } /// Returns the module stored in cache. If the module has not been cached, or it exists but is /// not valid, [None] is returned. - pub(crate) fn get(&self, key: &K) -> Option>>> { - self.module_cache.acquire().get(key).and_then(|module| { - if module.is_valid() { - Some(module.inner().clone()) - } else { - None - } - }) + pub fn get_valid(&self, key: &K) -> Option>> { + self.module_cache + .get(key) + .and_then(|entry| entry.is_valid().then(|| Arc::clone(entry.module_code()))) + } + + /// Returns the number of entries in the cache. + pub fn num_modules(&self) -> usize { + self.module_cache.len() + } + + /// Returns the sum of serialized sizes of modules stored in cache. + pub fn size_in_bytes(&self) -> usize { + self.size } - /// Flushes the cache. Should never be called throughout block-execution. Use with caution. - pub fn flush_unchecked(&self) { - self.module_cache.acquire().clear(); + /// Flushes the module cache. + pub fn flush_unsync(&mut self) { + self.module_cache.clear(); + self.size = 0; } - /// Inserts modules into the cache. Should never be called throughout block-execution. Use with - /// caution. - /// + /// Inserts modules into the cache. /// Notes: /// 1. Only verified modules are inserted. - /// 2. Versions of inserted modules are set to [None] (storage version). - /// 3. Valid modules should not be removed, and new modules should have unique ownership. If + /// 2. Valid modules should not be removed, and new modules should have unique ownership. If /// these constraints are violated, a panic error is returned. - /// 4. If the cache size exceeds its capacity after all verified modules have been inserted, - /// the cache is flushed. - pub(crate) fn insert_verified_unchecked( - &self, - modules: impl Iterator>>)>, + pub fn insert_verified_unsync( + &mut self, + modules: impl Iterator>)>, ) -> Result<(), PanicError> { use hashbrown::hash_map::Entry::*; - let mut guard = self.module_cache.acquire(); - let module_cache = guard.dereference_mut(); - for (key, module) in modules { - if let Occupied(entry) = module_cache.entry(key.clone()) { + if let Occupied(entry) = self.module_cache.entry(key.clone()) { if entry.get().is_valid() { return Err(PanicError::CodeInvariantError( "Should never overwrite a valid module".to_string(), )); } else { // Otherwise, remove the invalid entry. + let size = entry.get().module_code().extension().size_in_bytes(); + self.size -= size; entry.remove(); } } if module.code().is_verified() { - let mut module = module.as_ref().clone(); - module.set_version(None); - let prev = - module_cache.insert(key.clone(), ImmutableModuleCode::new(Arc::new(module))?); + self.size += module.extension().size_in_bytes(); + let entry = + Entry::new(module).expect("Module has been checked and must be verified"); + let prev = self.module_cache.insert(key.clone(), entry); // At this point, we must have removed the entry, or returned a panic error. assert!(prev.is_none()) } } - - if module_cache.len() > self.capacity { - module_cache.clear(); - } - Ok(()) } /// Insert the module to cache. Used for tests only. #[cfg(any(test, feature = "testing"))] - pub fn insert(&self, key: K, module: Arc>>) { - self.module_cache - .acquire() - .insert(key, ImmutableModuleCode::new(module).unwrap()); - } - - /// Removes the module from cache. Used for tests only. - #[cfg(any(test, feature = "testing"))] - pub fn remove(&self, key: &K) { - self.module_cache.acquire().remove(key); + pub fn insert(&mut self, key: K, module: Arc>) { + self.size += module.extension().size_in_bytes(); + self.module_cache.insert( + key, + Entry::new(module).expect("Module code should be verified"), + ); } - /// Returns the size of the cache. Used for tests only. + /// Removes the module from cache and returns true. If the module does not exist for the + /// associated key, returns false. Used for tests only. #[cfg(any(test, feature = "testing"))] - pub fn size(&self) -> usize { - self.module_cache.acquire().len() + pub fn remove(&mut self, key: &K) -> bool { + if let Some(entry) = self.module_cache.remove(key) { + self.size -= entry.module_code().extension().size_in_bytes(); + true + } else { + false + } } } #[cfg(test)] mod test { use super::*; - use claims::{assert_err, assert_ok, assert_some}; - use move_vm_types::code::{mock_deserialized_code, mock_verified_code}; + use claims::{assert_err, assert_ok}; + use move_vm_types::code::{mock_deserialized_code, mock_verified_code, MockExtension}; #[test] - fn test_immutable_module_code() { - assert!(ImmutableModuleCode::new(mock_deserialized_code(0, None)).is_err()); - assert!(ImmutableModuleCode::new(mock_deserialized_code(0, Some(22))).is_err()); - assert!(ImmutableModuleCode::new(mock_verified_code(0, Some(22))).is_err()); - assert!(ImmutableModuleCode::new(mock_verified_code(0, None)).is_ok()); + fn test_entry_new() { + assert!(Entry::new(mock_deserialized_code(0, MockExtension::new(8))).is_err()); + assert!(Entry::new(mock_verified_code(0, MockExtension::new(8))).is_ok()); } #[test] - fn test_immutable_module_code_validity() { - let module_code = assert_ok!(ImmutableModuleCode::new(mock_verified_code(0, None))); - assert!(module_code.is_valid()); + fn test_entry_mark_invalid() { + let entry = assert_ok!(Entry::new(mock_verified_code(0, MockExtension::new(8)))); + assert!(entry.is_valid()); - module_code.mark_invalid(); - assert!(!module_code.is_valid()); + entry.mark_invalid(); + assert!(!entry.is_valid()); } #[test] - fn test_global_module_cache() { - let global_cache = ImmutableModuleCache::empty(); + fn test_cache_contains_valid_and_get() { + let mut cache = GlobalModuleCache::empty(); - global_cache.insert(0, mock_verified_code(0, None)); - global_cache.insert(1, mock_verified_code(1, None)); - global_cache.mark_invalid(&1); + // Set the state. + cache.insert(0, mock_verified_code(0, MockExtension::new(8))); + cache.insert(1, mock_verified_code(1, MockExtension::new(8))); + cache.mark_invalid_if_contains(&1); - assert_eq!(global_cache.size(), 2); + assert_eq!(cache.num_modules(), 2); - assert!(global_cache.contains_valid(&0)); - assert!(!global_cache.contains_valid(&1)); - assert!(!global_cache.contains_valid(&3)); + assert!(cache.contains_valid(&0)); + assert!(!cache.contains_valid(&1)); + assert!(!cache.contains_valid(&3)); - assert!(global_cache.get(&0).is_some()); - assert!(global_cache.get(&1).is_none()); - assert!(global_cache.get(&3).is_none()); + assert!(cache.get_valid(&0).is_some()); + assert!(cache.get_valid(&1).is_none()); + assert!(cache.get_valid(&3).is_none()); } #[test] - fn test_insert_verified_for_global_module_cache() { - let capacity = 10; - let global_cache = ImmutableModuleCache::with_capacity(capacity); + fn test_cache_sizes_and_flush_unchecked() { + let mut cache = GlobalModuleCache::empty(); + assert_eq!(cache.num_modules(), 0); + assert_eq!(cache.size_in_bytes(), 0); + + cache.insert(0, mock_verified_code(0, MockExtension::new(8))); + cache.insert(1, mock_verified_code(1, MockExtension::new(16))); + cache.insert(2, mock_verified_code(2, MockExtension::new(8))); + assert_eq!(cache.num_modules(), 3); + assert_eq!(cache.size_in_bytes(), 32); + + assert!(cache.remove(&2)); + assert_eq!(cache.num_modules(), 2); + assert_eq!(cache.size_in_bytes(), 24); + + cache.flush_unsync(); + assert_eq!(cache.num_modules(), 0); + assert_eq!(cache.size_in_bytes(), 0); + } + + #[test] + fn test_cache_insert_verified_unchecked() { + let mut cache = GlobalModuleCache::empty(); let mut new_modules = vec![]; - for i in 0..capacity { - new_modules.push((i, mock_verified_code(i, Some(i as TxnIndex)))); - } - let result = global_cache.insert_verified_unchecked(new_modules.into_iter()); - assert!(result.is_ok()); - assert_eq!(global_cache.size(), capacity); - - // Versions should be set to storage. - for key in 0..capacity { - let code = assert_some!(global_cache.get(&key)); - assert!(code.version().is_none()) + for i in 0..10 { + new_modules.push((i, mock_verified_code(i, MockExtension::new(8)))); } + assert!(cache + .insert_verified_unsync(new_modules.into_iter()) + .is_ok()); + + assert_eq!(cache.num_modules(), 10); + assert_eq!(cache.size_in_bytes(), 80); + } + + #[test] + fn test_cache_insert_verified_unchecked_does_not_add_deserialized_code() { + let mut cache = GlobalModuleCache::empty(); + + let deserialized_modules = vec![(0, mock_deserialized_code(0, MockExtension::new(8)))]; + assert_ok!(cache.insert_verified_unsync(deserialized_modules.into_iter())); + + assert_eq!(cache.num_modules(), 0); + assert_eq!(cache.size_in_bytes(), 0); + } + + #[test] + fn test_cache_insert_verified_unchecked_does_not_override_valid_modules() { + let mut cache = GlobalModuleCache::empty(); + + cache.insert(0, mock_verified_code(0, MockExtension::new(8))); + assert_eq!(cache.num_modules(), 1); + assert_eq!(cache.size_in_bytes(), 8); + + let new_modules = vec![(0, mock_verified_code(100, MockExtension::new(32)))]; + assert_err!(cache.insert_verified_unsync(new_modules.into_iter())); + } + + #[test] + fn test_cache_insert_verified_unchecked_overrides_invalid_modules() { + let mut cache = GlobalModuleCache::empty(); + + cache.insert(0, mock_verified_code(0, MockExtension::new(8))); + cache.mark_invalid_if_contains(&0); + assert_eq!(cache.num_modules(), 1); + assert_eq!(cache.size_in_bytes(), 8); + + let new_modules = vec![(0, mock_verified_code(100, MockExtension::new(32)))]; + assert_ok!(cache.insert_verified_unsync(new_modules.into_iter())); - // Too many modules added, the cache should be flushed. - let new_modules = vec![(11, mock_verified_code(11, None))]; - let result = global_cache.insert_verified_unchecked(new_modules.into_iter()); - assert!(result.is_ok()); - assert_eq!(global_cache.size(), 0); - - // Should not add deserialized code. - let deserialized_modules = vec![(0, mock_deserialized_code(0, None))]; - assert_ok!(global_cache.insert_verified_unchecked(deserialized_modules.into_iter())); - assert_eq!(global_cache.size(), 0); - - // Should not override valid modules. - global_cache.insert(0, mock_verified_code(0, None)); - let new_modules = vec![(0, mock_verified_code(100, None))]; - assert_err!(global_cache.insert_verified_unchecked(new_modules.into_iter())); - - // Can override invalid modules. - global_cache.mark_invalid(&0); - let new_modules = vec![(0, mock_verified_code(100, None))]; - let result = global_cache.insert_verified_unchecked(new_modules.into_iter()); - assert!(result.is_ok()); - assert_eq!(global_cache.size(), 1); + assert_eq!(cache.num_modules(), 1); + assert_eq!(cache.size_in_bytes(), 32); } } diff --git a/aptos-move/block-executor/src/code_cache_global_manager.rs b/aptos-move/block-executor/src/code_cache_global_manager.rs new file mode 100644 index 0000000000000..26fda4eb8a3be --- /dev/null +++ b/aptos-move/block-executor/src/code_cache_global_manager.rs @@ -0,0 +1,599 @@ +// Copyright © Aptos Foundation +// SPDX-License-Identifier: Apache-2.0 + +use crate::{ + code_cache_global::GlobalModuleCache, + counters::{ + GLOBAL_MODULE_CACHE_NUM_MODULES, GLOBAL_MODULE_CACHE_SIZE_IN_BYTES, + STRUCT_NAME_INDEX_MAP_NUM_ENTRIES, + }, + explicit_sync_wrapper::ExplicitSyncWrapper, +}; +use aptos_types::block_executor::config::BlockExecutorModuleCacheLocalConfig; +use aptos_vm_environment::environment::AptosEnvironment; +use move_binary_format::errors::Location; +use move_core_types::vm_status::{StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR, VMStatus}; +use move_vm_runtime::WithRuntimeEnvironment; +use move_vm_types::code::WithSize; +use parking_lot::{Mutex, RwLock}; +use std::{ + fmt::Debug, + hash::Hash, + mem, + ops::{Deref, DerefMut}, + sync::Arc, +}; + +/// Raises an alert with the specified message. In case we run in testing mode, instead prints the +/// message to standard output. +macro_rules! alert_or_println { + ($($arg:tt)*) => { + if cfg!(any(test, feature = "testing")) { + println!($($arg)*) + } else { + use aptos_vm_logging::{alert, prelude::CRITICAL_ERRORS}; + use aptos_logger::error; + alert!($($arg)*); + } + }; +} + +/// Represents the state of [GlobalModuleCache]. The following transitions are allowed: +/// 2. [State::Ready] --> [State::Executing]. +/// 3. [State::Executing] --> [State::Done]. +/// 4. [State::Done] --> [State::Ready]. +/// The optional value stored in variants is propagated during state transitions. When a full cycle +/// is reached (just before [State::Done] to [State::Ready] transition), the user can check if the +/// value is expected and continue with a new one. For instance: +/// ```text +/// Ready(Some(0)) --> Executing(Some(0)) --> Done(Some(0)) --> Ready(Some(1)) is allowed. +/// Ready(Some(0)) --> Executing(Some(0)) --> Done(Some(0)) --> Ready(Some(2)) is not allowed. +/// ``` +#[derive(Clone, Debug, Eq, PartialEq)] +enum State { + Ready(Option), + Executing(Option), + Done(Option), +} + +/// Manages module caches and the execution environment, possible across multiple blocks. +pub struct ModuleCacheManager { + /// The state of global caches. + state: Mutex>, + + /// During concurrent executions, this module cache is read-only. However, it can be mutated + /// when it is known that there are no concurrent accesses. [ModuleCacheManager] must ensure + /// the safety. + // TODO(loader_v2): Remove this Arc when the feature is enabled on mainnet. + module_cache: Arc>>, + /// The execution environment, initially set to [None]. The environment, as long as it does not + /// change, can be kept for multiple block executions. + environment: ExplicitSyncWrapper>, +} + +impl ModuleCacheManager +where + T: Debug + Eq, + K: Hash + Eq + Clone, + VC: Deref>, + E: WithSize, +{ + /// Returns a new instance of [ModuleCacheManager] in a [State::Done] state with uninitialized + /// current value. + #[allow(clippy::new_without_default)] + pub fn new() -> Self { + Self { + state: Mutex::new(State::Done(None)), + module_cache: Arc::new(RwLock::new(GlobalModuleCache::empty())), + environment: ExplicitSyncWrapper::new(None), + } + } + + /// If state is [State::Done], sets the state to [State::Ready] with the current value and + /// returns true. Otherwise, raises an alert and returns false. Additionally, synchronizes + /// module and environment caches based on the provided previous value. + pub fn mark_ready(&self, previous: Option<&T>, current: Option) -> bool { + let mut state = self.state.lock(); + + if let State::Done(recorded_previous) = state.deref() { + // If the state is done, but the values do not exist or do not match, we flush global + // caches because they execute on top of unknown state (or on top of some different to + // the previous state). + if !recorded_previous + .as_ref() + .is_some_and(|r| previous.is_some_and(|p| r == p)) + { + if let Some(environment) = self.environment.acquire().as_ref() { + environment + .runtime_environment() + .flush_struct_name_and_info_caches(); + } + self.module_cache.write().flush_unsync(); + } + + *state = State::Ready(current); + true + } else { + // We are not in the done state, this is an error. + alert_or_println!( + "Unable to mark ready, state: {:?}, previous: {:?}, current: {:?}", + state, + previous, + current + ); + false + } + } + + /// When in [State::Ready], runs different checks on cached modules and environment: + /// 1. If the environment is not initialized, or is different from the one in storage, it is + /// re-initialized, and module caches are flushed. + /// 2. If too many struct names have been cached in re-indexing map in runtime environment, + /// struct type caches and module caches are flushed. + /// 3. If module cache size is too large (in bytes), it is flushed. + /// The final environment and module caches are returned. + pub fn check_ready_and_get_caches( + &self, + storage_environment: AptosEnvironment, + config: &BlockExecutorModuleCacheLocalConfig, + ) -> Result< + ( + AptosEnvironment, + Arc>>, + ), + VMStatus, + > { + let state = self.state.lock(); + if !matches!(state.deref(), State::Ready(_)) { + let msg = format!( + "Expected ready state to check caches, got {:?}", + state.deref() + ); + return Err(VMStatus::error( + UNKNOWN_INVARIANT_VIOLATION_ERROR, + Some(msg), + )); + } + + let environment = self.get_or_initialize_environment(storage_environment); + let module_cache = self.module_cache.clone(); + + // Check 1: struct re-indexing map is not too large. If it is, we flush the cache. Also, we + // need to flush modules because they store indices into re-indexing map. + let runtime_environment = environment.runtime_environment(); + let struct_name_index_map_size = runtime_environment + .struct_name_index_map_size() + .map_err(|err| err.finish(Location::Undefined).into_vm_status())?; + STRUCT_NAME_INDEX_MAP_NUM_ENTRIES.set(struct_name_index_map_size as i64); + + if struct_name_index_map_size > config.max_struct_name_index_map_num_entries { + module_cache.write().flush_unsync(); + runtime_environment.flush_struct_name_and_info_caches(); + } + + // Check 2: If the module cache is too big, flush it. + let module_cache_size_in_bytes = module_cache.read().size_in_bytes(); + GLOBAL_MODULE_CACHE_SIZE_IN_BYTES.set(module_cache_size_in_bytes as i64); + GLOBAL_MODULE_CACHE_NUM_MODULES.set(module_cache.read().num_modules() as i64); + + if module_cache_size_in_bytes > config.max_module_cache_size_in_bytes { + module_cache.write().flush_unsync(); + } + + Ok((environment, module_cache)) + } + + /// If state is [State::Ready], changes it to [State::Executing] with the same value, returning + /// true. Otherwise, returns false indicating that state transition failed, also raising an + /// alert. + pub fn mark_executing(&self) -> bool { + let mut state = self.state.lock(); + if let State::Ready(v) = state.deref_mut() { + *state = State::Executing(mem::take(v)); + true + } else { + alert_or_println!("Unable to mark executing, state: {:?}", state); + false + } + } + + /// If state is [State::Executing], changes it to [State::Done] with the same value, returning + /// true. Otherwise, returns false indicating that state transition failed, also raising an + /// alert. + pub fn mark_done(&self) -> bool { + let mut state = self.state.lock(); + if let State::Executing(v) = state.deref_mut() { + *state = State::Done(mem::take(v)); + true + } else { + alert_or_println!("Unable to mark done, state: {:?}", state); + false + } + } + + /// Returns the cached global environment if it already exists, and matches the one in storage. + /// If it does not exist, or does not match, the new environment is initialized from the given + /// state, cached, and returned. Should be called when in [State::Ready] state, under lock. + fn get_or_initialize_environment( + &self, + storage_environment: AptosEnvironment, + ) -> AptosEnvironment { + let mut guard = self.environment.acquire(); + let existing_environment = guard.deref_mut(); + + let environment_requires_update = existing_environment + .as_ref() + .map_or(true, |environment| environment != &storage_environment); + if environment_requires_update { + *existing_environment = Some(storage_environment); + + // If this environment has been (re-)initialized, we need to flush the module cache + // because it can contain now out-dated code. + self.module_cache.write().flush_unsync(); + } + + existing_environment + .clone() + .expect("Environment must be set") + } +} + +#[cfg(test)] +mod test { + use super::*; + use aptos_types::{ + on_chain_config::{FeatureFlag, Features, OnChainConfig}, + state_store::{state_key::StateKey, state_value::StateValue, MockStateView}, + }; + use claims::assert_ok; + use move_core_types::{ + account_address::AccountAddress, identifier::Identifier, language_storage::ModuleId, + }; + use move_vm_types::{ + code::{mock_verified_code, MockDeserializedCode, MockExtension, MockVerifiedCode}, + loaded_data::runtime_types::StructIdentifier, + }; + use std::{collections::HashMap, thread, thread::JoinHandle}; + use test_case::test_case; + + #[test_case(None, None)] + #[test_case(None, Some(1))] + #[test_case(Some(0), None)] + #[test_case(Some(0), Some(1))] + #[test_case(Some(0), Some(0))] + fn test_mark_ready(recorded_previous: Option, previous: Option) { + let module_cache_manager = ModuleCacheManager::new(); + *module_cache_manager.state.lock() = State::Done(recorded_previous); + + // Pre-populate module cache to test flushing. + module_cache_manager + .module_cache + .write() + .insert(0, mock_verified_code(0, MockExtension::new(8))); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 1); + + assert!(!module_cache_manager.mark_executing()); + assert!(!module_cache_manager.mark_done()); + assert!(module_cache_manager.mark_ready(previous.as_ref(), Some(77))); + + // Only in matching case the module cache is not flushed. + if recorded_previous.is_some() && recorded_previous == previous { + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 1); + } else { + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 0); + } + + let state = module_cache_manager.state.lock().clone(); + assert_eq!(state, State::Ready(Some(77))) + } + + #[test] + fn test_check_ready() { + let state_view = MockStateView::empty(); + let config = BlockExecutorModuleCacheLocalConfig { + prefetch_framework_code: false, + max_module_cache_size_in_bytes: 8, + max_struct_name_index_map_num_entries: 2, + }; + + let module_cache_manager = ModuleCacheManager::< + i32, + i32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::new(); + + // Set up the state and the environment. + *module_cache_manager.state.lock() = State::Ready(None); + let environment = module_cache_manager.get_or_initialize_environment( + AptosEnvironment::new_with_delayed_field_optimization_enabled(&state_view), + ); + + module_cache_manager + .module_cache + .write() + .insert(0, mock_verified_code(0, MockExtension::new(16))); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 1); + + let runtime_environment = environment.runtime_environment(); + let dummy_struct_name = StructIdentifier { + module: ModuleId::new(AccountAddress::ONE, Identifier::new("foo").unwrap()), + name: Identifier::new("Bar").unwrap(), + }; + assert!(runtime_environment + .struct_name_to_idx_for_test(dummy_struct_name) + .is_ok()); + assert_eq!( + assert_ok!(runtime_environment.struct_name_index_map_size()), + 1 + ); + + // Module cache size in bytes is too large, should be flushed (but not struct types). + assert!(module_cache_manager + .check_ready_and_get_caches(environment.clone(), &config) + .is_ok()); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 0); + assert_eq!( + assert_ok!(runtime_environment.struct_name_index_map_size()), + 1 + ); + + module_cache_manager + .module_cache + .write() + .insert(0, mock_verified_code(0, MockExtension::new(4))); + + // This time size is less than the one specified in config. No flushing. + assert!(module_cache_manager + .check_ready_and_get_caches(environment.clone(), &config) + .is_ok()); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 1); + assert_eq!( + assert_ok!(runtime_environment.struct_name_index_map_size()), + 1 + ); + + let dummy_struct_names = [ + StructIdentifier { + module: ModuleId::new(AccountAddress::ONE, Identifier::new("foo").unwrap()), + name: Identifier::new("Foo").unwrap(), + }, + StructIdentifier { + module: ModuleId::new(AccountAddress::ONE, Identifier::new("foo").unwrap()), + name: Identifier::new("Baz").unwrap(), + }, + ]; + for dummy_struct_name in dummy_struct_names { + assert!(runtime_environment + .struct_name_to_idx_for_test(dummy_struct_name) + .is_ok()); + } + assert_eq!( + assert_ok!(runtime_environment.struct_name_index_map_size()), + 3 + ); + + // Too many struct names cached. + assert!(module_cache_manager + .check_ready_and_get_caches(environment.clone(), &config) + .is_ok()); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 0); + assert_eq!( + assert_ok!(runtime_environment.struct_name_index_map_size()), + 0 + ); + } + + #[test] + fn test_mark_executing() { + let module_cache_manager = ModuleCacheManager::< + i32, + i32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::new(); + *module_cache_manager.state.lock() = State::Ready(Some(100)); + + assert!(!module_cache_manager.mark_ready(Some(&76), Some(77))); + assert!(!module_cache_manager.mark_done()); + + assert!(module_cache_manager.mark_executing()); + + let state = module_cache_manager.state.lock().clone(); + assert_eq!(state, State::Executing(Some(100))) + } + + #[test] + fn test_mark_done() { + let module_cache_manager = ModuleCacheManager::< + i32, + i32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::new(); + *module_cache_manager.state.lock() = State::Executing(Some(100)); + + assert!(!module_cache_manager.mark_ready(Some(&76), Some(77))); + assert!(!module_cache_manager.mark_executing()); + + assert!(module_cache_manager.mark_done()); + + let state = module_cache_manager.state.lock().clone(); + assert_eq!(state, State::Done(Some(100))) + } + + /// Joins threads. Succeeds only if a single handle evaluates to [Ok] and the rest are [Err]s. + fn join_and_assert_single_true(handles: Vec>) { + let mut num_true = 0; + let mut num_false = 0; + + let num_handles = handles.len(); + for handle in handles { + if handle.join().unwrap() { + num_true += 1; + } else { + num_false += 1; + } + } + assert_eq!(num_true, 1); + assert_eq!(num_false, num_handles - 1); + } + + #[test] + fn test_mark_ready_concurrent() { + let global_cache_manager = Arc::new(ModuleCacheManager::< + i32, + i32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::new()); + + let mut handles = vec![]; + for _ in 0..32 { + let handle = thread::spawn({ + let global_cache_manager = global_cache_manager.clone(); + move || global_cache_manager.mark_ready(Some(&1), Some(2)) + }); + handles.push(handle); + } + join_and_assert_single_true(handles); + } + + #[test] + fn test_mark_executing_concurrent() { + let global_cache_manager = Arc::new(ModuleCacheManager::< + i32, + i32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::new()); + assert!(global_cache_manager.mark_ready(Some(&0), Some(1))); + + let mut handles = vec![]; + for _ in 0..32 { + let handle = thread::spawn({ + let global_cache_manager = global_cache_manager.clone(); + move || global_cache_manager.mark_executing() + }); + handles.push(handle); + } + join_and_assert_single_true(handles); + } + + #[test] + fn test_mark_done_concurrent() { + let global_cache_manager = Arc::new(ModuleCacheManager::< + i32, + i32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::new()); + assert!(global_cache_manager.mark_ready(Some(&0), Some(1))); + assert!(global_cache_manager.mark_executing()); + + let mut handles = vec![]; + for _ in 0..32 { + let handle = thread::spawn({ + let global_cache_manager = global_cache_manager.clone(); + move || global_cache_manager.mark_done() + }); + handles.push(handle); + } + join_and_assert_single_true(handles); + } + + fn state_view_with_changed_feature_flag( + feature_flag: Option, + ) -> MockStateView { + // Tweak feature flags to force a different config. + let mut features = Features::default(); + + if let Some(feature_flag) = feature_flag { + if features.is_enabled(feature_flag) { + features.disable(feature_flag); + } else { + features.enable(feature_flag); + } + } + + MockStateView::new(HashMap::from([( + StateKey::resource(Features::address(), &Features::struct_tag()).unwrap(), + StateValue::new_legacy(bcs::to_bytes(&features).unwrap().into()), + )])) + } + + #[test] + fn test_get_or_initialize_environment() { + let module_cache_manager = ModuleCacheManager::< + i32, + i32, + MockDeserializedCode, + MockVerifiedCode, + MockExtension, + >::new(); + *module_cache_manager.state.lock() = State::Ready(None); + + module_cache_manager + .module_cache + .write() + .insert(0, mock_verified_code(0, MockExtension::new(8))); + module_cache_manager + .module_cache + .write() + .insert(1, mock_verified_code(1, MockExtension::new(8))); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 2); + assert!(module_cache_manager.environment.acquire().is_none()); + + // Environment has to be set to the same value, cache flushed. + let state_view = state_view_with_changed_feature_flag(None); + let environment = module_cache_manager.get_or_initialize_environment( + AptosEnvironment::new_with_delayed_field_optimization_enabled(&state_view), + ); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 0); + assert!(module_cache_manager + .environment + .acquire() + .as_ref() + .is_some_and(|cached_environment| cached_environment == &environment)); + + module_cache_manager + .module_cache + .write() + .insert(2, mock_verified_code(2, MockExtension::new(8))); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 1); + assert!(module_cache_manager.environment.acquire().is_some()); + + // Environment has to be re-set to the new value, cache flushed. + let state_view = + state_view_with_changed_feature_flag(Some(FeatureFlag::CODE_DEPENDENCY_CHECK)); + let environment = module_cache_manager.get_or_initialize_environment( + AptosEnvironment::new_with_delayed_field_optimization_enabled(&state_view), + ); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 0); + assert!(module_cache_manager + .environment + .acquire() + .as_ref() + .is_some_and(|cached_environment| cached_environment == &environment)); + + module_cache_manager + .module_cache + .write() + .insert(3, mock_verified_code(3, MockExtension::new(8))); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 1); + assert!(module_cache_manager.environment.acquire().is_some()); + + // Environment is kept, and module caches are not flushed. + let new_environment = module_cache_manager.get_or_initialize_environment( + AptosEnvironment::new_with_delayed_field_optimization_enabled(&state_view), + ); + assert_eq!(module_cache_manager.module_cache.read().num_modules(), 1); + assert!(environment == new_environment); + } +} diff --git a/aptos-move/block-executor/src/counters.rs b/aptos-move/block-executor/src/counters.rs index c3f1dc61f8fd3..e75d1b3354805 100644 --- a/aptos-move/block-executor/src/counters.rs +++ b/aptos-move/block-executor/src/counters.rs @@ -3,8 +3,8 @@ use aptos_metrics_core::{ exponential_buckets, register_avg_counter_vec, register_histogram, register_histogram_vec, - register_int_counter, register_int_counter_vec, Histogram, HistogramVec, IntCounter, - IntCounterVec, + register_int_counter, register_int_counter_vec, register_int_gauge, Histogram, HistogramVec, + IntCounter, IntCounterVec, IntGauge, }; use aptos_mvhashmap::BlockStateStats; use aptos_types::fee_statement::FeeStatement; @@ -333,3 +333,27 @@ pub(crate) fn update_state_counters(block_state_stats: BlockStateStats, is_paral .with_label_values(&[mode_str, "delayed_field"]) .observe(block_state_stats.base_delayed_fields_size as f64); } + +pub static GLOBAL_MODULE_CACHE_SIZE_IN_BYTES: Lazy = Lazy::new(|| { + register_int_gauge!( + "global_module_cache_size_in_bytes", + "Sum of sizes of all serialized modules stored in global module cache" + ) + .unwrap() +}); + +pub static GLOBAL_MODULE_CACHE_NUM_MODULES: Lazy = Lazy::new(|| { + register_int_gauge!( + "global_module_cache_num_modules", + "Number of modules cached in global module cache" + ) + .unwrap() +}); + +pub static STRUCT_NAME_INDEX_MAP_NUM_ENTRIES: Lazy = Lazy::new(|| { + register_int_gauge!( + "struct_name_index_map_num_entries", + "Number of struct names interned and cached in execution environment" + ) + .unwrap() +}); diff --git a/aptos-move/block-executor/src/executor.rs b/aptos-move/block-executor/src/executor.rs index 182ff626059f0..0f3890d0a6585 100644 --- a/aptos-move/block-executor/src/executor.rs +++ b/aptos-move/block-executor/src/executor.rs @@ -3,7 +3,7 @@ // SPDX-License-Identifier: Apache-2.0 use crate::{ - code_cache_global::ImmutableModuleCache, + code_cache_global::GlobalModuleCache, counters::{ self, BLOCK_EXECUTOR_INNER_EXECUTE_BLOCK, PARALLEL_EXECUTION_SECONDS, RAYON_EXECUTION_SECONDS, TASK_EXECUTE_SECONDS, TASK_VALIDATE_SECONDS, VM_INIT_SECONDS, @@ -58,11 +58,13 @@ use move_core_types::{language_storage::ModuleId, value::MoveTypeLayout, vm_stat use move_vm_runtime::{Module, RuntimeEnvironment, WithRuntimeEnvironment}; use move_vm_types::code::ModuleCache; use num_cpus; +use parking_lot::RwLock; use rayon::ThreadPool; use std::{ cell::RefCell, collections::{BTreeMap, HashMap, HashSet}, marker::{PhantomData, Sync}, + ops::Deref, sync::{ atomic::{AtomicBool, AtomicU32, Ordering}, Arc, @@ -74,8 +76,6 @@ pub struct BlockExecutor { // threads that may be concurrently participating in parallel execution. config: BlockExecutorConfig, executor_thread_pool: Arc, - global_module_cache: - Arc>, transaction_commit_hook: Option, phantom: PhantomData<(T, E, S, L, X)>, } @@ -93,9 +93,6 @@ where pub fn new( config: BlockExecutorConfig, executor_thread_pool: Arc, - global_module_cache: Arc< - ImmutableModuleCache, - >, transaction_commit_hook: Option, ) -> Self { assert!( @@ -106,7 +103,6 @@ where Self { config, executor_thread_pool, - global_module_cache, transaction_commit_hook, phantom: PhantomData, } @@ -120,7 +116,7 @@ where versioned_cache: &MVHashMap, executor: &E, base_view: &S, - global_module_cache: &ImmutableModuleCache< + global_module_cache: &GlobalModuleCache< ModuleId, CompiledModule, Module, @@ -402,7 +398,7 @@ where fn validate( idx_to_validate: TxnIndex, last_input_output: &TxnLastInputOutput, - global_module_cache: &ImmutableModuleCache< + global_module_cache: &GlobalModuleCache< ModuleId, CompiledModule, Module, @@ -560,6 +556,7 @@ where /// in outputs, which is heavier (due to serialization / deserialization, copies, etc). Moreover, /// since prepare_and_queue_commit_ready_txns takes care of synchronization in the flag-combining /// way, the materialization can be almost embarrassingly parallelizable. + #[allow(clippy::too_many_arguments)] fn prepare_and_queue_commit_ready_txns( &self, block_gas_limit_type: &BlockGasLimitType, @@ -569,6 +566,12 @@ where last_input_output: &TxnLastInputOutput, shared_commit_state: &ExplicitSyncWrapper>, base_view: &S, + global_module_cache: &GlobalModuleCache< + ModuleId, + CompiledModule, + Module, + AptosModuleExtension, + >, runtime_environment: &RuntimeEnvironment, start_shared_counter: u32, shared_counter: &AtomicU32, @@ -605,7 +608,7 @@ where versioned_cache, executor, base_view, - self.global_module_cache.as_ref(), + global_module_cache, runtime_environment, ParallelState::new( versioned_cache, @@ -624,7 +627,7 @@ where Self::publish_module_writes( txn_idx, module_write_set, - self.global_module_cache.as_ref(), + global_module_cache, versioned_cache, scheduler, runtime_environment, @@ -637,7 +640,7 @@ where let validation_result = Self::validate( txn_idx, last_input_output, - self.global_module_cache.as_ref(), + global_module_cache, versioned_cache, scheduler, ); @@ -666,7 +669,7 @@ where Self::publish_module_writes( txn_idx, module_write_set, - self.global_module_cache.as_ref(), + global_module_cache, versioned_cache, scheduler, runtime_environment, @@ -755,7 +758,7 @@ where fn publish_module_writes( txn_idx: TxnIndex, module_write_set: BTreeMap>, - global_module_cache: &ImmutableModuleCache< + global_module_cache: &GlobalModuleCache< ModuleId, CompiledModule, Module, @@ -841,6 +844,12 @@ where shared_counter: &AtomicU32, last_input_output: &TxnLastInputOutput, base_view: &S, + global_module_cache: &GlobalModuleCache< + ModuleId, + CompiledModule, + Module, + AptosModuleExtension, + >, runtime_environment: &RuntimeEnvironment, final_results: &ExplicitSyncWrapper>, ) -> Result<(), PanicError> { @@ -852,7 +861,7 @@ where ); let latest_view = LatestView::new( base_view, - self.global_module_cache.as_ref(), + global_module_cache, runtime_environment, ViewState::Sync(parallel_state), txn_idx, @@ -946,6 +955,12 @@ where scheduler: &Scheduler, // TODO: should not need to pass base view. base_view: &S, + global_module_cache: &GlobalModuleCache< + ModuleId, + CompiledModule, + Module, + AptosModuleExtension, + >, start_shared_counter: u32, shared_counter: &AtomicU32, shared_commit_state: &ExplicitSyncWrapper>, @@ -974,6 +989,7 @@ where shared_counter, last_input_output, base_view, + global_module_cache, runtime_environment, final_results, )?; @@ -1001,6 +1017,7 @@ where last_input_output, shared_commit_state, base_view, + global_module_cache, runtime_environment, start_shared_counter, shared_counter, @@ -1018,7 +1035,7 @@ where let valid = Self::validate( txn_idx, last_input_output, - self.global_module_cache.as_ref(), + global_module_cache, versioned_cache, scheduler, ); @@ -1046,7 +1063,7 @@ where versioned_cache, &executor, base_view, - self.global_module_cache.as_ref(), + global_module_cache, runtime_environment, ParallelState::new( versioned_cache, @@ -1084,6 +1101,9 @@ where env: &E::Environment, signature_verified_block: &[T], base_view: &S, + global_module_cache: &RwLock< + GlobalModuleCache, + >, ) -> Result, ()> { let _timer = PARALLEL_EXECUTION_SECONDS.start_timer(); // Using parallel execution with 1 thread currently will not work as it @@ -1126,6 +1146,11 @@ where let scheduler = Scheduler::new(num_txns); let timer = RAYON_EXECUTION_SECONDS.start_timer(); + + // Read lock for execution because global cache is not mutated. + let global_module_cache_read_lock = global_module_cache.read(); + let immutable_global_module_cache = global_module_cache_read_lock.deref(); + self.executor_thread_pool.scope(|s| { for _ in 0..num_workers { s.spawn(|_| { @@ -1136,6 +1161,7 @@ where &versioned_cache, &scheduler, base_view, + immutable_global_module_cache, start_shared_counter, &shared_counter, &shared_commit_state, @@ -1156,6 +1182,7 @@ where }); } }); + drop(global_module_cache_read_lock); drop(timer); if !shared_maybe_error.load(Ordering::SeqCst) && scheduler.pop_from_commit_queue().is_ok() { @@ -1168,8 +1195,9 @@ where } counters::update_state_counters(versioned_cache.stats(), true); - self.global_module_cache - .insert_verified_unchecked(versioned_cache.take_modules_iter()) + global_module_cache + .write() + .insert_verified_unsync(versioned_cache.take_modules_iter()) .map_err(|err| { alert!("[BlockSTM] Encountered panic error: {:?}", err); })?; @@ -1198,7 +1226,7 @@ where write: ModuleWrite, txn_idx: TxnIndex, runtime_environment: &RuntimeEnvironment, - global_module_cache: &ImmutableModuleCache< + global_module_cache: &GlobalModuleCache< ModuleId, CompiledModule, Module, @@ -1226,16 +1254,11 @@ where let msg = format!("Failed to construct the module from state value: {:?}", err); PanicError::CodeInvariantError(msg) })?; - let extension = AptosModuleExtension::new(state_value); + let extension = Arc::new(AptosModuleExtension::new(state_value)); - global_module_cache.mark_invalid(&id); + global_module_cache.mark_invalid_if_contains(&id); per_block_module_cache - .insert_deserialized_module( - id.clone(), - compiled_module, - Arc::new(extension), - Some(txn_idx), - ) + .insert_deserialized_module(id.clone(), compiled_module, extension, Some(txn_idx)) .map_err(|err| { let msg = format!( "Failed to insert code for module {}::{} at version {} to module cache: {:?}", @@ -1252,7 +1275,7 @@ where fn apply_output_sequential( txn_idx: TxnIndex, runtime_environment: &RuntimeEnvironment, - global_module_cache: &ImmutableModuleCache< + global_module_cache: &GlobalModuleCache< ModuleId, CompiledModule, Module, @@ -1347,6 +1370,9 @@ where env: &E::Environment, signature_verified_block: &[T], base_view: &S, + global_module_cache: &RwLock< + GlobalModuleCache, + >, resource_group_bcs_fallback: bool, ) -> Result, SequentialBlockExecutionError> { let num_txns = signature_verified_block.len(); @@ -1368,10 +1394,14 @@ where let last_input_output: TxnLastInputOutput = TxnLastInputOutput::new(num_txns as TxnIndex); + // Global module cache is only readable throughout execution. + let global_module_cache_read_lock = global_module_cache.read(); + let immutable_global_module_cache = global_module_cache_read_lock.deref(); + for (idx, txn) in signature_verified_block.iter().enumerate() { let latest_view = LatestView::::new( base_view, - self.global_module_cache.as_ref(), + immutable_global_module_cache, runtime_environment, ViewState::Unsync(SequentialState::new(&unsync_map, start_counter, &counter)), idx as TxnIndex, @@ -1563,7 +1593,7 @@ where Self::apply_output_sequential( idx as TxnIndex, runtime_environment, - self.global_module_cache.as_ref(), + immutable_global_module_cache, &unsync_map, &output, resource_write_set.clone(), @@ -1651,8 +1681,13 @@ where ret.resize_with(num_txns, E::Output::skip_output); counters::update_state_counters(unsync_map.stats(), false); - self.global_module_cache - .insert_verified_unchecked(unsync_map.into_modules_iter())?; + + // Release the read lock on the global module cache, and acquire a write lock to mutate + // it by adding cached modules from unsync map. + drop(global_module_cache_read_lock); + global_module_cache + .write() + .insert_verified_unsync(unsync_map.into_modules_iter())?; let block_end_info = if self .config @@ -1691,12 +1726,19 @@ where env: E::Environment, signature_verified_block: &[T], base_view: &S, + global_module_cache: &RwLock< + GlobalModuleCache, + >, ) -> BlockExecutionResult, E::Error> { let _timer = BLOCK_EXECUTOR_INNER_EXECUTE_BLOCK.start_timer(); if self.config.local.concurrency_level > 1 { - let parallel_result = - self.execute_transactions_parallel(&env, signature_verified_block, base_view); + let parallel_result = self.execute_transactions_parallel( + &env, + signature_verified_block, + base_view, + global_module_cache, + ); // If parallel gave us result, return it if let Ok(output) = parallel_result { @@ -1714,14 +1756,19 @@ where // Flush the cache and the environment to re-run from the "clean" state. env.runtime_environment() .flush_struct_name_and_info_caches(); - self.global_module_cache.flush_unchecked(); + global_module_cache.write().flush_unsync(); info!("parallel execution requiring fallback"); } // If we didn't run parallel, or it didn't finish successfully - run sequential - let sequential_result = - self.execute_transactions_sequential(&env, signature_verified_block, base_view, false); + let sequential_result = self.execute_transactions_sequential( + &env, + signature_verified_block, + base_view, + global_module_cache, + false, + ); // If sequential gave us result, return it let sequential_error = match sequential_result { @@ -1743,6 +1790,7 @@ where &env, signature_verified_block, base_view, + global_module_cache, true, ); diff --git a/aptos-move/block-executor/src/lib.rs b/aptos-move/block-executor/src/lib.rs index d7bfdc4a0c5cf..f2d388f769008 100644 --- a/aptos-move/block-executor/src/lib.rs +++ b/aptos-move/block-executor/src/lib.rs @@ -142,6 +142,7 @@ extern crate scopeguard; mod captured_reads; mod code_cache; pub mod code_cache_global; +pub mod code_cache_global_manager; pub mod counters; pub mod errors; pub mod executor; diff --git a/aptos-move/block-executor/src/proptest_types/bencher.rs b/aptos-move/block-executor/src/proptest_types/bencher.rs index b34768150a126..ec9a6a7883765 100644 --- a/aptos-move/block-executor/src/proptest_types/bencher.rs +++ b/aptos-move/block-executor/src/proptest_types/bencher.rs @@ -3,23 +3,24 @@ // SPDX-License-Identifier: Apache-2.0 use crate::{ - code_cache_global::ImmutableModuleCache, + code_cache_global::GlobalModuleCache, executor::BlockExecutor, proptest_types::{ baseline::BaselineOutput, types::{ - EmptyDataView, KeyType, MockEnvironment, MockOutput, MockTask, MockTransaction, - TransactionGen, TransactionGenParams, + KeyType, MockEnvironment, MockOutput, MockTask, MockTransaction, TransactionGen, + TransactionGenParams, }, }, txn_commit_hook::NoOpTransactionCommitHook, }; use aptos_types::{ block_executor::config::BlockExecutorConfig, contract_event::TransactionEvent, - executable::ExecutableTestType, + executable::ExecutableTestType, state_store::MockStateView, }; use criterion::{BatchSize, Bencher as CBencher}; use num_cpus; +use parking_lot::RwLock; use proptest::{ arbitrary::Arbitrary, collection::vec, @@ -118,9 +119,7 @@ where } pub(crate) fn run(self) { - let data_view = EmptyDataView::> { - phantom: PhantomData, - }; + let state_view = MockStateView::empty(); let executor_thread_pool = Arc::new( rayon::ThreadPoolBuilder::new() @@ -128,18 +127,19 @@ where .build() .unwrap(), ); - let global_module_cache = Arc::new(ImmutableModuleCache::empty()); let config = BlockExecutorConfig::new_no_block_limit(num_cpus::get()); let env = MockEnvironment::new(); + let global_module_cache = RwLock::new(GlobalModuleCache::empty()); + let output = BlockExecutor::< MockTransaction, E>, MockTask, E>, - EmptyDataView>, + MockStateView>, NoOpTransactionCommitHook, E>, usize>, ExecutableTestType, - >::new(config, executor_thread_pool, global_module_cache, None) - .execute_transactions_parallel(&env, &self.transactions, &data_view); + >::new(config, executor_thread_pool, None) + .execute_transactions_parallel(&env, &self.transactions, &state_view, &global_module_cache); self.baseline_output.assert_parallel_output(&output); } diff --git a/aptos-move/block-executor/src/proptest_types/tests.rs b/aptos-move/block-executor/src/proptest_types/tests.rs index 7ed0894bec414..d80a1452fa19d 100644 --- a/aptos-move/block-executor/src/proptest_types/tests.rs +++ b/aptos-move/block-executor/src/proptest_types/tests.rs @@ -3,14 +3,14 @@ // SPDX-License-Identifier: Apache-2.0 use crate::{ - code_cache_global::ImmutableModuleCache, + code_cache_global::GlobalModuleCache, errors::SequentialBlockExecutionError, executor::BlockExecutor, proptest_types::{ baseline::BaselineOutput, types::{ - DeltaDataView, EmptyDataView, KeyType, MockEnvironment, MockEvent, MockOutput, - MockTask, MockTransaction, NonEmptyGroupDataView, TransactionGen, TransactionGenParams, + DeltaDataView, KeyType, MockEnvironment, MockEvent, MockOutput, MockTask, + MockTransaction, NonEmptyGroupDataView, TransactionGen, TransactionGenParams, MAX_GAS_PER_TXN, }, }, @@ -18,10 +18,11 @@ use crate::{ }; use aptos_types::{ block_executor::config::BlockExecutorConfig, contract_event::TransactionEvent, - executable::ExecutableTestType, + executable::ExecutableTestType, state_store::MockStateView, }; use claims::{assert_matches, assert_ok}; use num_cpus; +use parking_lot::RwLock; use proptest::{ collection::vec, prelude::*, @@ -60,9 +61,7 @@ fn run_transactions( *transactions.get_mut(i.index(length)).unwrap() = MockTransaction::SkipRest(0); } - let data_view = EmptyDataView::> { - phantom: PhantomData, - }; + let state_view = MockStateView::empty(); let executor_thread_pool = Arc::new( rayon::ThreadPoolBuilder::new() @@ -73,19 +72,25 @@ fn run_transactions( for _ in 0..num_repeat { let env = MockEnvironment::new(); + let global_module_cache = RwLock::new(GlobalModuleCache::empty()); + let output = BlockExecutor::< MockTransaction, E>, MockTask, E>, - EmptyDataView>, + MockStateView>, NoOpTransactionCommitHook, E>, usize>, ExecutableTestType, >::new( BlockExecutorConfig::new_maybe_block_limit(num_cpus::get(), maybe_block_gas_limit), executor_thread_pool.clone(), - Arc::new(ImmutableModuleCache::empty()), None, ) - .execute_transactions_parallel(&env, &transactions, &data_view); + .execute_transactions_parallel( + &env, + &transactions, + &state_view, + &global_module_cache, + ); if module_access.0 && module_access.1 { assert_matches!(output, Err(())); @@ -210,6 +215,8 @@ fn deltas_writes_mixed_with_block_gas_limit(num_txns: usize, maybe_block_gas_lim for _ in 0..20 { let env = MockEnvironment::new(); + let global_module_cache = RwLock::new(GlobalModuleCache::empty()); + let output = BlockExecutor::< MockTransaction, MockEvent>, MockTask, MockEvent>, @@ -219,10 +226,14 @@ fn deltas_writes_mixed_with_block_gas_limit(num_txns: usize, maybe_block_gas_lim >::new( BlockExecutorConfig::new_maybe_block_limit(num_cpus::get(), maybe_block_gas_limit), executor_thread_pool.clone(), - Arc::new(ImmutableModuleCache::empty()), None, ) - .execute_transactions_parallel(&env, &transactions, &data_view); + .execute_transactions_parallel( + &env, + &transactions, + &data_view, + &global_module_cache, + ); BaselineOutput::generate(&transactions, maybe_block_gas_limit) .assert_parallel_output(&output); @@ -263,6 +274,8 @@ fn deltas_resolver_with_block_gas_limit(num_txns: usize, maybe_block_gas_limit: for _ in 0..20 { let env = MockEnvironment::new(); + let global_module_cache = RwLock::new(GlobalModuleCache::empty()); + let output = BlockExecutor::< MockTransaction, MockEvent>, MockTask, MockEvent>, @@ -272,10 +285,14 @@ fn deltas_resolver_with_block_gas_limit(num_txns: usize, maybe_block_gas_limit: >::new( BlockExecutorConfig::new_maybe_block_limit(num_cpus::get(), maybe_block_gas_limit), executor_thread_pool.clone(), - Arc::new(ImmutableModuleCache::empty()), None, ) - .execute_transactions_parallel(&env, &transactions, &data_view); + .execute_transactions_parallel( + &env, + &transactions, + &data_view, + &global_module_cache, + ); BaselineOutput::generate(&transactions, maybe_block_gas_limit) .assert_parallel_output(&output); @@ -421,6 +438,8 @@ fn publishing_fixed_params_with_block_gas_limit( // Confirm still no intersection let env = MockEnvironment::new(); + let global_module_cache = RwLock::new(GlobalModuleCache::empty()); + let output = BlockExecutor::< MockTransaction, MockEvent>, MockTask, MockEvent>, @@ -430,10 +449,9 @@ fn publishing_fixed_params_with_block_gas_limit( >::new( BlockExecutorConfig::new_maybe_block_limit(num_cpus::get(), maybe_block_gas_limit), executor_thread_pool, - Arc::new(ImmutableModuleCache::empty()), None, ) - .execute_transactions_parallel(&env, &transactions, &data_view); + .execute_transactions_parallel(&env, &transactions, &data_view, &global_module_cache); assert_ok!(output); // Adjust the reads of txn indices[2] to contain module read to key 42. @@ -465,6 +483,8 @@ fn publishing_fixed_params_with_block_gas_limit( for _ in 0..200 { let env = MockEnvironment::new(); + let global_module_cache = RwLock::new(GlobalModuleCache::empty()); + let output = BlockExecutor::< MockTransaction, MockEvent>, MockTask, MockEvent>, @@ -477,10 +497,14 @@ fn publishing_fixed_params_with_block_gas_limit( Some(max(w_index, r_index) as u64 * MAX_GAS_PER_TXN + 1), ), executor_thread_pool.clone(), - Arc::new(ImmutableModuleCache::empty()), None, ) // Ensure enough gas limit to commit the module txns (4 is maximum gas per txn) - .execute_transactions_parallel(&env, &transactions, &data_view); + .execute_transactions_parallel( + &env, + &transactions, + &data_view, + &global_module_cache, + ); assert_matches!(output, Err(())); } @@ -549,6 +573,8 @@ fn non_empty_group( for _ in 0..num_repeat_parallel { let env = MockEnvironment::new(); + let global_module_cache = RwLock::new(GlobalModuleCache::empty()); + let output = BlockExecutor::< MockTransaction, MockEvent>, MockTask, MockEvent>, @@ -558,16 +584,22 @@ fn non_empty_group( >::new( BlockExecutorConfig::new_no_block_limit(num_cpus::get()), executor_thread_pool.clone(), - Arc::new(ImmutableModuleCache::empty()), None, ) - .execute_transactions_parallel(&env, &transactions, &data_view); + .execute_transactions_parallel( + &env, + &transactions, + &data_view, + &global_module_cache, + ); BaselineOutput::generate(&transactions, None).assert_parallel_output(&output); } for _ in 0..num_repeat_sequential { let env = MockEnvironment::new(); + let global_module_cache = RwLock::new(GlobalModuleCache::empty()); + let output = BlockExecutor::< MockTransaction, MockEvent>, MockTask, MockEvent>, @@ -577,10 +609,15 @@ fn non_empty_group( >::new( BlockExecutorConfig::new_no_block_limit(num_cpus::get()), executor_thread_pool.clone(), - Arc::new(ImmutableModuleCache::empty()), None, ) - .execute_transactions_sequential(&env, &transactions, &data_view, false); + .execute_transactions_sequential( + &env, + &transactions, + &data_view, + &global_module_cache, + false, + ); // TODO: test dynamic disabled as well. BaselineOutput::generate(&transactions, None).assert_output(&output.map_err(|e| match e { diff --git a/aptos-move/block-executor/src/proptest_types/types.rs b/aptos-move/block-executor/src/proptest_types/types.rs index 507e27fa7999a..27e6bdfb53653 100644 --- a/aptos-move/block-executor/src/proptest_types/types.rs +++ b/aptos-move/block-executor/src/proptest_types/types.rs @@ -122,30 +122,6 @@ where } } -pub(crate) struct EmptyDataView { - pub(crate) phantom: PhantomData, -} - -impl TStateView for EmptyDataView -where - K: PartialOrd + Ord + Send + Sync + Clone + Hash + Eq + ModulePath + 'static, -{ - type Key = K; - - /// Gets the state value for a given state key. - fn get_state_value(&self, _: &K) -> Result, StateviewError> { - Ok(None) - } - - fn id(&self) -> StateViewId { - StateViewId::Miscellaneous - } - - fn get_usage(&self) -> Result { - unreachable!("Not used in tests"); - } -} - /////////////////////////////////////////////////////////////////////////// // Generation of transactions /////////////////////////////////////////////////////////////////////////// diff --git a/aptos-move/block-executor/src/unit_tests/mod.rs b/aptos-move/block-executor/src/unit_tests/mod.rs index 4f7fb54a41155..7ef9fd793e4bf 100644 --- a/aptos-move/block-executor/src/unit_tests/mod.rs +++ b/aptos-move/block-executor/src/unit_tests/mod.rs @@ -5,7 +5,7 @@ mod code_cache_tests; use crate::{ - code_cache_global::ImmutableModuleCache, + code_cache_global::GlobalModuleCache, errors::SequentialBlockExecutionError, executor::BlockExecutor, proptest_types::{ @@ -35,6 +35,7 @@ use aptos_types::{ }; use claims::{assert_matches, assert_ok}; use fail::FailScenario; +use parking_lot::RwLock; use rand::{prelude::*, random}; use std::{ cmp::min, @@ -87,7 +88,6 @@ fn test_resource_group_deletion() { >::new( BlockExecutorConfig::new_no_block_limit(num_cpus::get()), executor_thread_pool, - Arc::new(ImmutableModuleCache::empty()), None, ); @@ -96,9 +96,15 @@ fn test_resource_group_deletion() { &env, &transactions, &data_view, + &RwLock::new(GlobalModuleCache::empty()), false )); - assert_ok!(block_executor.execute_transactions_parallel(&env, &transactions, &data_view)); + assert_ok!(block_executor.execute_transactions_parallel( + &env, + &transactions, + &data_view, + &RwLock::new(GlobalModuleCache::empty()) + )); } #[test] @@ -154,13 +160,17 @@ fn resource_group_bcs_fallback() { >::new( BlockExecutorConfig::new_no_block_limit(num_cpus::get()), executor_thread_pool, - Arc::new(ImmutableModuleCache::empty()), None, ); // Execute the block normally. let env = MockEnvironment::new(); - let output = block_executor.execute_transactions_parallel(&env, &transactions, &data_view); + let output = block_executor.execute_transactions_parallel( + &env, + &transactions, + &data_view, + &RwLock::new(GlobalModuleCache::empty()), + ); match output { Ok(block_output) => { let txn_outputs = block_output.into_transaction_outputs_forced(); @@ -179,12 +189,22 @@ fn resource_group_bcs_fallback() { assert!(!fail::list().is_empty()); let env = MockEnvironment::new(); - let par_output = block_executor.execute_transactions_parallel(&env, &transactions, &data_view); + let par_output = block_executor.execute_transactions_parallel( + &env, + &transactions, + &data_view, + &RwLock::new(GlobalModuleCache::empty()), + ); assert_matches!(par_output, Err(())); let env = MockEnvironment::new(); - let seq_output = - block_executor.execute_transactions_sequential(&env, &transactions, &data_view, false); + let seq_output = block_executor.execute_transactions_sequential( + &env, + &transactions, + &data_view, + &RwLock::new(GlobalModuleCache::empty()), + false, + ); assert_matches!( seq_output, Err(SequentialBlockExecutionError::ResourceGroupSerializationError) @@ -193,7 +213,13 @@ fn resource_group_bcs_fallback() { // Now execute with fallback handling for resource group serialization error: let env = MockEnvironment::new(); let fallback_output = block_executor - .execute_transactions_sequential(&env, &transactions, &data_view, true) + .execute_transactions_sequential( + &env, + &transactions, + &data_view, + &RwLock::new(GlobalModuleCache::empty()), + true, + ) .map_err(|e| match e { SequentialBlockExecutionError::ResourceGroupSerializationError => { panic!("Unexpected error") @@ -202,7 +228,12 @@ fn resource_group_bcs_fallback() { }); let env = MockEnvironment::new(); - let fallback_output_block = block_executor.execute_block(env, &transactions, &data_view); + let fallback_output_block = block_executor.execute_block( + env, + &transactions, + &data_view, + &RwLock::new(GlobalModuleCache::empty()), + ); for output in [fallback_output, fallback_output_block] { match output { Ok(block_output) => { @@ -254,7 +285,6 @@ fn block_output_err_precedence() { >::new( BlockExecutorConfig::new_no_block_limit(num_cpus::get()), executor_thread_pool, - Arc::new(ImmutableModuleCache::empty()), None, ); @@ -265,7 +295,12 @@ fn block_output_err_precedence() { // Pause the thread that processes the aborting txn1, so txn2 can halt the scheduler first. // Confirm that the fatal VM error is still detected and sequential fallback triggered. let env = MockEnvironment::new(); - let output = block_executor.execute_transactions_parallel(&env, &transactions, &data_view); + let output = block_executor.execute_transactions_parallel( + &env, + &transactions, + &data_view, + &RwLock::new(GlobalModuleCache::empty()), + ); assert_matches!(output, Err(())); scenario.teardown(); } @@ -294,13 +329,17 @@ fn skip_rest_gas_limit() { >::new( BlockExecutorConfig::new_maybe_block_limit(num_cpus::get(), Some(5)), executor_thread_pool, - Arc::new(ImmutableModuleCache::empty()), None, ); // Should hit block limit on the skip transaction. let env = MockEnvironment::new(); - let _ = block_executor.execute_transactions_parallel(&env, &transactions, &data_view); + let _ = block_executor.execute_transactions_parallel( + &env, + &transactions, + &data_view, + &RwLock::new(GlobalModuleCache::empty()), + ); } // TODO: add unit test for block gas limit! @@ -330,10 +369,14 @@ where >::new( BlockExecutorConfig::new_no_block_limit(num_cpus::get()), executor_thread_pool, - Arc::new(ImmutableModuleCache::empty()), None, ) - .execute_transactions_parallel(&env, &transactions, &data_view); + .execute_transactions_parallel( + &env, + &transactions, + &data_view, + &RwLock::new(GlobalModuleCache::empty()), + ); let baseline = BaselineOutput::generate(&transactions, None); baseline.assert_parallel_output(&output); diff --git a/aptos-move/block-executor/src/view.rs b/aptos-move/block-executor/src/view.rs index b70f67a544d5c..0659662c09e89 100644 --- a/aptos-move/block-executor/src/view.rs +++ b/aptos-move/block-executor/src/view.rs @@ -8,7 +8,7 @@ use crate::{ CapturedReads, DataRead, DelayedFieldRead, DelayedFieldReadKind, GroupRead, ReadKind, UnsyncReadSet, }, - code_cache_global::ImmutableModuleCache, + code_cache_global::GlobalModuleCache, counters, scheduler::{DependencyResult, DependencyStatus, Scheduler, TWaitForDependency}, value_exchange::{ @@ -991,7 +991,7 @@ impl<'a, T: Transaction, X: Executable> ViewState<'a, T, X> { pub(crate) struct LatestView<'a, T: Transaction, S: TStateView, X: Executable> { base_view: &'a S, pub(crate) global_module_cache: - &'a ImmutableModuleCache, + &'a GlobalModuleCache, pub(crate) runtime_environment: &'a RuntimeEnvironment, pub(crate) latest_view: ViewState<'a, T, X>, pub(crate) txn_idx: TxnIndex, @@ -1000,7 +1000,7 @@ pub(crate) struct LatestView<'a, T: Transaction, S: TStateView, X: impl<'a, T: Transaction, S: TStateView, X: Executable> LatestView<'a, T, S, X> { pub(crate) fn new( base_view: &'a S, - global_module_cache: &'a ImmutableModuleCache< + global_module_cache: &'a GlobalModuleCache< ModuleId, CompiledModule, Module, @@ -1824,10 +1824,7 @@ mod test { use aptos_types::{ error::PanicOr, executable::Executable, - state_store::{ - errors::StateviewError, state_storage_usage::StateStorageUsage, - state_value::StateValue, TStateView, - }, + state_store::{state_value::StateValue, MockStateView}, transaction::BlockExecutableTransaction, write_set::TransactionWrite, }; @@ -2478,33 +2475,6 @@ mod test { StateValue::new_legacy(value.simple_serialize(layout).unwrap().into()) } - // TODO: Check how to import MockStateView from other tests - // rather than rewriting it here again - struct MockStateView { - data: HashMap, StateValue>, - } - - impl MockStateView { - fn new(data: HashMap, StateValue>) -> Self { - Self { data } - } - } - - impl TStateView for MockStateView { - type Key = KeyType; - - fn get_state_value( - &self, - state_key: &Self::Key, - ) -> Result, StateviewError> { - Ok(self.data.get(state_key).cloned()) - } - - fn get_usage(&self) -> Result { - unimplemented!(); - } - } - #[derive(Clone)] struct MockExecutable {} @@ -2518,18 +2488,19 @@ mod test { fn test_id_value_exchange() { let unsync_map = UnsyncMap::new(); let counter = RefCell::new(5); - let base_view = MockStateView::new(HashMap::new()); + let base_view = MockStateView::empty(); let start_counter = 5; let runtime_environment = RuntimeEnvironment::new(vec![]); - let global_module_cache = ImmutableModuleCache::empty(); - - let latest_view = LatestView::::new( - &base_view, - &global_module_cache, - &runtime_environment, - ViewState::Unsync(SequentialState::new(&unsync_map, start_counter, &counter)), - 1, - ); + let global_module_cache = GlobalModuleCache::empty(); + + let latest_view = + LatestView::>, MockExecutable>::new( + &base_view, + &global_module_cache, + &runtime_environment, + ViewState::Unsync(SequentialState::new(&unsync_map, start_counter, &counter)), + 1, + ); // Test id -- value exchange for a value that does not contain delayed fields let layout = MoveTypeLayout::Struct(MoveStructLayout::new(vec![ @@ -2788,9 +2759,9 @@ mod test { struct Holder { unsync_map: UnsyncMap, u32, ValueType, DelayedFieldID>, counter: RefCell, - base_view: MockStateView, + base_view: MockStateView>, empty_global_module_cache: - ImmutableModuleCache, + GlobalModuleCache, runtime_environment: RuntimeEnvironment, } @@ -2804,7 +2775,7 @@ mod test { unsync_map, counter, base_view, - empty_global_module_cache: ImmutableModuleCache::empty(), + empty_global_module_cache: GlobalModuleCache::empty(), runtime_environment, } } @@ -2812,11 +2783,11 @@ mod test { fn create_sequential_latest_view<'a>( h: &'a Holder, - ) -> LatestView<'a, TestTransactionType, MockStateView, MockExecutable> { + ) -> LatestView<'a, TestTransactionType, MockStateView>, MockExecutable> { let sequential_state: SequentialState<'a, TestTransactionType> = SequentialState::new(&h.unsync_map, *h.counter.borrow(), &h.counter); - LatestView::<'a, TestTransactionType, MockStateView, MockExecutable>::new( + LatestView::<'a, TestTransactionType, MockStateView>, MockExecutable>::new( &h.base_view, &h.empty_global_module_cache, &h.runtime_environment, @@ -2829,7 +2800,7 @@ mod test { start_counter: u32, holder: Holder, counter: AtomicU32, - base_view: MockStateView, + base_view: MockStateView>, runtime_environment: RuntimeEnvironment, versioned_map: MVHashMap, u32, ValueType, MockExecutable, DelayedFieldID>, scheduler: Scheduler, @@ -2857,19 +2828,22 @@ mod test { fn new_view(&self) -> ViewsComparison<'_> { let latest_view_seq = create_sequential_latest_view(&self.holder); - let latest_view_par = - LatestView::::new( - &self.base_view, - &self.holder.empty_global_module_cache, - &self.runtime_environment, - ViewState::Sync(ParallelState::new( - &self.versioned_map, - &self.scheduler, - self.start_counter, - &self.counter, - )), - 1, - ); + let latest_view_par = LatestView::< + TestTransactionType, + MockStateView>, + MockExecutable, + >::new( + &self.base_view, + &self.holder.empty_global_module_cache, + &self.runtime_environment, + ViewState::Sync(ParallelState::new( + &self.versioned_map, + &self.scheduler, + self.start_counter, + &self.counter, + )), + 1, + ); ViewsComparison { latest_view_seq, @@ -2879,8 +2853,10 @@ mod test { } struct ViewsComparison<'a> { - latest_view_seq: LatestView<'a, TestTransactionType, MockStateView, MockExecutable>, - latest_view_par: LatestView<'a, TestTransactionType, MockStateView, MockExecutable>, + latest_view_seq: + LatestView<'a, TestTransactionType, MockStateView>, MockExecutable>, + latest_view_par: + LatestView<'a, TestTransactionType, MockStateView>, MockExecutable>, } impl<'a> ViewsComparison<'a> { diff --git a/aptos-move/e2e-tests/src/executor.rs b/aptos-move/e2e-tests/src/executor.rs index b97961dad4efc..da4598abf98c5 100644 --- a/aptos-move/e2e-tests/src/executor.rs +++ b/aptos-move/e2e-tests/src/executor.rs @@ -14,7 +14,9 @@ use crate::{ }; use aptos_abstract_gas_usage::CalibrationAlgebra; use aptos_bitvec::BitVec; -use aptos_block_executor::txn_commit_hook::NoOpTransactionCommitHook; +use aptos_block_executor::{ + code_cache_global_manager::ModuleCacheManager, txn_commit_hook::NoOpTransactionCommitHook, +}; use aptos_crypto::HashValue; use aptos_framework::ReleaseBundle; use aptos_gas_algebra::DynamicExpression; @@ -28,6 +30,7 @@ use aptos_types::{ }, block_executor::config::{ BlockExecutorConfig, BlockExecutorConfigFromOnchain, BlockExecutorLocalConfig, + BlockExecutorModuleCacheLocalConfig, }, block_metadata::BlockMetadata, chain_id::ChainId, @@ -633,18 +636,23 @@ impl FakeExecutor { }, allow_fallback: self.allow_block_executor_fallback, discard_failed_blocks: false, + module_cache_config: BlockExecutorModuleCacheLocalConfig::default(), }, onchain: onchain_config, }; - BlockAptosVM::execute_block_on_thread_pool_without_global_module_cache::< + BlockAptosVM::execute_block_on_thread_pool::< _, NoOpTransactionCommitHook, >( self.executor_thread_pool.clone(), txn_block, &state_view, + // Do not use shared module caches in tests. + &ModuleCacheManager::new(), config, None, + None, + None, ) .map(BlockOutput::into_transaction_outputs_forced) } diff --git a/aptos-move/mvhashmap/src/lib.rs b/aptos-move/mvhashmap/src/lib.rs index cd6fa6134826f..3241a99ff1a0e 100644 --- a/aptos-move/mvhashmap/src/lib.rs +++ b/aptos-move/mvhashmap/src/lib.rs @@ -125,7 +125,7 @@ impl< ) -> impl Iterator< Item = ( ModuleId, - Arc>>, + Arc>, ), > { self.module_cache.take_modules_iter() diff --git a/aptos-move/mvhashmap/src/unsync_map.rs b/aptos-move/mvhashmap/src/unsync_map.rs index e909c60b2ef22..c4c67948ed5b3 100644 --- a/aptos-move/mvhashmap/src/unsync_map.rs +++ b/aptos-move/mvhashmap/src/unsync_map.rs @@ -110,7 +110,7 @@ impl< ) -> impl Iterator< Item = ( ModuleId, - Arc>>, + Arc>, ), > { self.module_cache.into_modules_iter() diff --git a/crates/transaction-generator-lib/src/args.rs b/crates/transaction-generator-lib/src/args.rs index b19bf2651e8b4..7a1e2330f3af6 100644 --- a/crates/transaction-generator-lib/src/args.rs +++ b/crates/transaction-generator-lib/src/args.rs @@ -73,6 +73,9 @@ pub enum TransactionTypeArg { SmartTablePicture1MWith1KChangeExceedsLimit, DeserializeU256, SimpleScript, + ChainDependencies, + ChainFriends, + StarDependencies, } impl TransactionTypeArg { @@ -320,6 +323,13 @@ impl TransactionTypeArg { }, TransactionTypeArg::DeserializeU256 => call_custom_module(EntryPoints::DeserializeU256), TransactionTypeArg::SimpleScript => call_custom_module(EntryPoints::SimpleScript), + TransactionTypeArg::ChainDependencies => { + call_custom_module(EntryPoints::ChainDependencies) + }, + TransactionTypeArg::ChainFriends => call_custom_module(EntryPoints::ChainFriends), + TransactionTypeArg::StarDependencies => { + call_custom_module(EntryPoints::StarDependencies) + }, } } diff --git a/crates/transaction-generator-lib/src/publishing/module_simple.rs b/crates/transaction-generator-lib/src/publishing/module_simple.rs index 0bc7b959fb408..83be768e25d4e 100644 --- a/crates/transaction-generator-lib/src/publishing/module_simple.rs +++ b/crates/transaction-generator-lib/src/publishing/module_simple.rs @@ -272,6 +272,9 @@ pub enum EntryPoints { /// there to slow down deserialization & verification, effectively making it more expensive to /// load it into code cache. SimpleScript, + ChainDependencies, + ChainFriends, + StarDependencies, } impl EntryPoints { @@ -329,6 +332,9 @@ impl EntryPoints { EntryPoints::IncGlobalMilestoneAggV2 { .. } | EntryPoints::CreateGlobalMilestoneAggV2 { .. } => "aggregator_examples", EntryPoints::DeserializeU256 => "bcs_stream", + EntryPoints::ChainDependencies => "module_loading_chain_dependencies", + EntryPoints::ChainFriends => "module_loading_chain_friends", + EntryPoints::StarDependencies => "module_loading_star_dependencies", } } @@ -389,6 +395,9 @@ impl EntryPoints { EntryPoints::IncGlobalMilestoneAggV2 { .. } | EntryPoints::CreateGlobalMilestoneAggV2 { .. } => "counter_with_milestone", EntryPoints::DeserializeU256 => "bcs_stream", + EntryPoints::ChainDependencies => "chain_dependencies", + EntryPoints::ChainFriends => "chain_friends", + EntryPoints::StarDependencies => "star_dependencies", } } @@ -732,6 +741,11 @@ impl EntryPoints { ], ) }, + EntryPoints::ChainDependencies + | EntryPoints::ChainFriends + | EntryPoints::StarDependencies => { + get_payload_void(module_id, ident_str!("run").to_owned()) + }, } } @@ -840,6 +854,9 @@ impl EntryPoints { EntryPoints::DeserializeU256 => AutomaticArgs::None, EntryPoints::IncGlobalMilestoneAggV2 { .. } => AutomaticArgs::None, EntryPoints::CreateGlobalMilestoneAggV2 { .. } => AutomaticArgs::Signer, + EntryPoints::ChainDependencies + | EntryPoints::ChainFriends + | EntryPoints::StarDependencies => AutomaticArgs::None, } } } diff --git a/crates/transaction-generator-lib/src/publishing/raw_module_data.rs b/crates/transaction-generator-lib/src/publishing/raw_module_data.rs index 4deb1a72d1709..f3edf4b7134d2 100644 --- a/crates/transaction-generator-lib/src/publishing/raw_module_data.rs +++ b/crates/transaction-generator-lib/src/publishing/raw_module_data.rs @@ -15,6 +15,2121 @@ use once_cell::sync::Lazy; use std::collections::HashMap; +#[rustfmt::skip] +pub static PACKAGE_MODULE_LOADING_STAR_DEPENDENCIES_METADATA: Lazy> = Lazy::new(|| { + vec![ + 32, 109, 111, 100, 117, 108, 101, 95, 108, 111, 97, 100, 105, 110, 103, 95, 115, 116, + 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 1, 0, 0, + 0, 0, 0, 0, 0, 0, 64, 55, 56, 67, 69, 65, 53, 49, 70, 70, 65, 56, + 51, 51, 70, 48, 66, 55, 52, 68, 55, 67, 57, 51, 66, 50, 70, 68, 52, 67, + 66, 56, 67, 54, 69, 69, 70, 55, 70, 48, 67, 50, 48, 70, 52, 56, 57, 65, + 65, 52, 68, 69, 57, 67, 66, 52, 51, 50, 68, 48, 69, 55, 55, 54, 53, 170, + 1, 31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 77, 141, 65, 14, 130, 48, 16, + 69, 247, 61, 69, 195, 134, 149, 21, 15, 224, 2, 245, 6, 46, 9, 105, 6, 58, + 98, 67, 233, 52, 29, 64, 19, 227, 221, 109, 13, 11, 146, 89, 76, 126, 222, 127, + 191, 9, 208, 143, 48, 96, 43, 60, 76, 40, 207, 178, 156, 200, 44, 14, 181, 35, + 48, 214, 15, 154, 103, 136, 218, 96, 64, 111, 208, 247, 22, 185, 20, 43, 70, 182, + 228, 51, 124, 82, 149, 170, 74, 33, 154, 61, 209, 138, 58, 204, 196, 247, 217, 56, + 219, 37, 234, 35, 29, 245, 224, 210, 87, 40, 117, 220, 31, 100, 238, 48, 209, 138, + 199, 71, 76, 251, 47, 138, 227, 22, 242, 191, 93, 200, 111, 146, 131, 49, 17, 153, + 179, 57, 44, 157, 179, 252, 196, 168, 183, 48, 91, 171, 119, 125, 185, 222, 10, 241, + 3, 239, 45, 19, 107, 205, 0, 0, 0, 21, 19, 115, 116, 97, 114, 95, 100, 101, + 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 57, 0, 0, 0, 19, 115, 116, + 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 56, 0, + 0, 0, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, + 101, 115, 95, 55, 0, 0, 0, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, + 100, 101, 110, 99, 105, 101, 115, 95, 54, 0, 0, 0, 19, 115, 116, 97, 114, 95, + 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 53, 0, 0, 0, 19, + 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, + 52, 0, 0, 0, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, + 99, 105, 101, 115, 95, 51, 0, 0, 0, 20, 115, 116, 97, 114, 95, 100, 101, 112, + 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 50, 48, 0, 0, 0, 19, 115, 116, + 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 50, 0, + 0, 0, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, + 101, 115, 95, 49, 57, 0, 0, 0, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, + 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 56, 0, 0, 0, 20, 115, 116, 97, + 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 55, 0, + 0, 0, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, + 101, 115, 95, 49, 54, 0, 0, 0, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, + 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 53, 0, 0, 0, 20, 115, 116, 97, + 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 52, 0, + 0, 0, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, + 101, 115, 95, 49, 51, 0, 0, 0, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, + 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 50, 0, 0, 0, 20, 115, 116, 97, + 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 49, 0, + 0, 0, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, + 101, 115, 95, 49, 48, 0, 0, 0, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, + 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 0, 0, 0, 17, 115, 116, 97, 114, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 0, 0, 0, 2, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 11, 65, 112, 116, 111, + 115, 83, 116, 100, 108, 105, 98, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 10, 77, 111, 118, 101, 83, 116, 100, 108, 105, 98, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_9: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 117, 8, 216, 1, 64, 16, 152, 2, 31, 10, + 183, 2, 22, 12, 205, 2, 204, 2, 13, 153, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 57, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, + 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, + 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, + 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, + 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, + 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, + 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, + 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, + 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, + 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, + 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, + 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, + 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, + 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, + 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, + 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, + 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, + 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, + 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, + 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, + 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, + 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_8: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 117, 8, 216, 1, 64, 16, 152, 2, 31, 10, + 183, 2, 22, 12, 205, 2, 204, 2, 13, 153, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 56, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, + 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, + 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, + 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, + 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, + 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, + 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, + 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, + 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, + 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, + 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, + 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, + 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, + 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, + 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, + 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, + 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, + 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, + 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, + 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, + 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, + 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_7: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 117, 8, 216, 1, 64, 16, 152, 2, 31, 10, + 183, 2, 22, 12, 205, 2, 204, 2, 13, 153, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 55, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, + 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, + 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, + 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, + 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, + 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, + 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, + 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, + 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, + 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, + 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, + 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, + 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, + 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, + 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, + 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, + 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, + 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, + 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, + 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, + 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, + 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_6: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 117, 8, 216, 1, 64, 16, 152, 2, 31, 10, + 183, 2, 22, 12, 205, 2, 204, 2, 13, 153, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 54, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, + 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, + 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, + 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, + 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, + 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, + 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, + 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, + 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, + 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, + 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, + 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, + 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, + 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, + 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, + 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, + 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, + 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, + 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, + 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, + 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, + 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_5: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 117, 8, 216, 1, 64, 16, 152, 2, 31, 10, + 183, 2, 22, 12, 205, 2, 204, 2, 13, 153, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 53, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, + 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, + 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, + 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, + 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, + 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, + 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, + 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, + 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, + 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, + 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, + 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, + 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, + 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, + 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, + 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, + 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, + 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, + 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, + 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, + 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, + 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_4: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 117, 8, 216, 1, 64, 16, 152, 2, 31, 10, + 183, 2, 22, 12, 205, 2, 204, 2, 13, 153, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 52, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, + 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, + 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, + 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, + 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, + 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, + 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, + 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, + 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, + 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, + 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, + 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, + 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, + 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, + 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, + 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, + 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, + 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, + 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, + 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, + 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, + 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_3: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 117, 8, 216, 1, 64, 16, 152, 2, 31, 10, + 183, 2, 22, 12, 205, 2, 204, 2, 13, 153, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 51, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, + 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, + 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, + 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, + 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, + 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, + 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, + 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, + 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, + 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, + 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, + 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, + 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, + 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, + 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, + 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, + 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, + 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, + 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, + 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, + 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, + 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_20: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 50, 48, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_2: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 117, 8, 216, 1, 64, 16, 152, 2, 31, 10, + 183, 2, 22, 12, 205, 2, 204, 2, 13, 153, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 50, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, + 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, + 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, + 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, + 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, + 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, + 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, + 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, + 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, + 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, + 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, + 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, + 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, + 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, + 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, + 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, + 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, + 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, + 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, + 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, + 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, + 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_19: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 57, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_18: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 56, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_17: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 55, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_16: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 54, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_15: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 53, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_14: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 52, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_13: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 51, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_12: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 50, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_11: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 49, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_10: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 118, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 204, 2, 13, 154, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 48, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, + 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, + 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, + 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, + 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, + 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, + 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, + 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, + 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, + 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, + 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, + 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, + 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, + 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, + 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, + 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, + 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, + 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, + 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, + 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, + 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_1: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 117, 8, 216, 1, 64, 16, 152, 2, 31, 10, + 183, 2, 22, 12, 205, 2, 204, 2, 13, 153, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 49, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, + 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, + 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, + 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, + 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, + 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, + 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, + 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, + 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, + 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, + 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, + 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, + 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, + 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, + 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, + 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, + 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, + 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, + 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, + 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, + 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, + 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 7, 1, 0, 42, 3, 42, 126, 5, 168, 1, + 7, 7, 175, 1, 182, 3, 8, 229, 4, 32, 16, 133, 5, 31, 12, 164, 5, 130, + 2, 0, 0, 0, 2, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, + 10, 0, 11, 0, 12, 0, 13, 0, 14, 0, 15, 0, 16, 0, 17, 0, 18, 0, + 19, 0, 20, 0, 21, 0, 22, 0, 1, 0, 0, 0, 1, 1, 3, 0, 1, 0, + 1, 2, 3, 0, 1, 0, 1, 3, 3, 0, 1, 0, 1, 4, 3, 0, 1, 0, + 1, 5, 3, 0, 1, 0, 1, 6, 3, 0, 1, 0, 1, 7, 3, 0, 1, 0, + 1, 8, 3, 0, 1, 0, 1, 9, 3, 0, 1, 0, 1, 10, 3, 0, 1, 0, + 1, 11, 3, 0, 1, 0, 1, 12, 3, 0, 1, 0, 1, 13, 3, 0, 1, 0, + 1, 14, 3, 0, 1, 0, 1, 15, 3, 0, 1, 0, 1, 16, 3, 0, 1, 0, + 1, 17, 3, 0, 1, 0, 1, 18, 3, 0, 1, 0, 1, 19, 3, 0, 1, 0, + 1, 20, 3, 0, 1, 0, 1, 0, 1, 3, 3, 3, 3, 3, 17, 115, 116, 97, + 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 3, 114, 117, 110, + 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, + 95, 49, 4, 110, 101, 120, 116, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, + 100, 101, 110, 99, 105, 101, 115, 95, 50, 19, 115, 116, 97, 114, 95, 100, 101, 112, + 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 51, 19, 115, 116, 97, 114, 95, 100, + 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 52, 19, 115, 116, 97, 114, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 53, 19, 115, 116, + 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 54, 19, + 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, + 55, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, + 115, 95, 56, 19, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, + 105, 101, 115, 95, 57, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 49, 48, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, + 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 49, 20, 115, 116, 97, 114, 95, 100, + 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 50, 20, 115, 116, 97, + 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 51, 20, + 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, + 49, 52, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, + 101, 115, 95, 49, 53, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 49, 54, 20, 115, 116, 97, 114, 95, 100, 101, 112, 101, + 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 55, 20, 115, 116, 97, 114, 95, 100, + 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 56, 20, 115, 116, 97, + 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 57, 20, + 115, 116, 97, 114, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, + 50, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 20, 99, + 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, + 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 1, 4, 0, 2, 127, 17, + 1, 12, 1, 6, 0, 0, 0, 0, 0, 0, 0, 0, 11, 1, 22, 12, 0, 17, + 2, 12, 1, 11, 0, 11, 1, 22, 12, 0, 17, 3, 12, 1, 11, 0, 11, 1, + 22, 12, 0, 17, 4, 12, 1, 11, 0, 11, 1, 22, 12, 0, 17, 5, 12, 1, + 11, 0, 11, 1, 22, 12, 0, 17, 6, 12, 1, 11, 0, 11, 1, 22, 12, 0, + 17, 7, 12, 1, 11, 0, 11, 1, 22, 12, 0, 17, 8, 12, 1, 11, 0, 11, + 1, 22, 12, 0, 17, 9, 12, 1, 11, 0, 11, 1, 22, 12, 0, 17, 10, 12, + 1, 11, 0, 11, 1, 22, 12, 0, 17, 11, 12, 1, 11, 0, 11, 1, 22, 12, + 0, 17, 12, 12, 1, 11, 0, 11, 1, 22, 12, 0, 17, 13, 12, 1, 11, 0, + 11, 1, 22, 12, 0, 17, 14, 12, 1, 11, 0, 11, 1, 22, 12, 0, 17, 15, + 12, 1, 11, 0, 11, 1, 22, 12, 0, 17, 16, 12, 1, 11, 0, 11, 1, 22, + 12, 0, 17, 17, 12, 1, 11, 0, 11, 1, 22, 12, 0, 17, 18, 12, 1, 11, + 0, 11, 1, 22, 12, 0, 17, 19, 12, 1, 11, 0, 11, 1, 22, 12, 0, 17, + 20, 12, 1, 11, 0, 11, 1, 22, 12, 2, 11, 2, 6, 20, 0, 0, 0, 0, + 0, 0, 0, 33, 4, 125, 2, 6, 77, 0, 0, 0, 0, 0, 0, 0, 39, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULES_MODULE_LOADING_STAR_DEPENDENCIES: Lazy>> = Lazy::new(|| { vec![ + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_9.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_8.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_7.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_6.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_5.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_4.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_3.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_20.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_2.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_19.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_18.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_17.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_16.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_15.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_14.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_13.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_12.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_11.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_10.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES_1.to_vec(), + MODULE_MODULE_LOADING_STAR_DEPENDENCIES_STAR_DEPENDENCIES.to_vec(), +]}); + +#[rustfmt::skip] +pub static PACKAGE_MODULE_LOADING_CHAIN_DEPENDENCIES_METADATA: Lazy> = Lazy::new(|| { + vec![ + 33, 109, 111, 100, 117, 108, 101, 95, 108, 111, 97, 100, 105, 110, 103, 95, 99, 104, + 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 64, 48, 53, 57, 68, 48, 55, 53, 69, 53, 49, + 56, 65, 67, 49, 67, 54, 65, 66, 54, 56, 48, 70, 51, 50, 53, 67, 57, 67, + 65, 51, 48, 55, 68, 57, 55, 69, 49, 49, 70, 49, 53, 66, 65, 52, 54, 67, + 65, 49, 66, 52, 51, 67, 70, 53, 67, 53, 48, 56, 65, 51, 54, 53, 70, 70, + 171, 1, 31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 77, 142, 65, 10, 131, 48, + 16, 69, 247, 57, 69, 112, 227, 170, 209, 30, 160, 11, 219, 222, 160, 75, 145, 48, + 38, 83, 13, 198, 36, 100, 212, 22, 74, 239, 222, 164, 184, 16, 102, 49, 124, 222, + 127, 252, 54, 128, 154, 96, 192, 142, 57, 152, 145, 95, 120, 57, 123, 189, 90, 148, + 214, 131, 54, 110, 144, 106, 4, 227, 164, 198, 128, 78, 163, 83, 6, 169, 100, 27, + 70, 50, 222, 101, 250, 44, 106, 81, 151, 140, 181, 71, 162, 99, 77, 88, 60, 61, + 22, 109, 77, 159, 168, 15, 183, 94, 129, 77, 95, 33, 68, 117, 60, 200, 220, 105, + 246, 27, 86, 207, 152, 6, 188, 124, 156, 246, 144, 254, 237, 130, 127, 147, 28, 180, + 142, 72, 148, 205, 97, 237, 173, 161, 17, 163, 220, 195, 108, 173, 223, 205, 245, 118, + 47, 216, 15, 168, 92, 114, 50, 206, 0, 0, 0, 21, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 50, 48, 0, 0, + 0, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, + 101, 115, 95, 49, 57, 0, 0, 0, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, + 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 56, 0, 0, 0, 21, 99, 104, + 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, + 55, 0, 0, 0, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 49, 54, 0, 0, 0, 21, 99, 104, 97, 105, 110, 95, + 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 53, 0, 0, 0, + 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, + 115, 95, 49, 52, 0, 0, 0, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, + 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 51, 0, 0, 0, 21, 99, 104, 97, + 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 50, + 0, 0, 0, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, + 99, 105, 101, 115, 95, 49, 49, 0, 0, 0, 21, 99, 104, 97, 105, 110, 95, 100, + 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 48, 0, 0, 0, 20, + 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, + 95, 57, 0, 0, 0, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 56, 0, 0, 0, 20, 99, 104, 97, 105, 110, 95, + 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 55, 0, 0, 0, 20, + 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, + 95, 54, 0, 0, 0, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 53, 0, 0, 0, 20, 99, 104, 97, 105, 110, 95, + 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 52, 0, 0, 0, 20, + 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, + 95, 51, 0, 0, 0, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 50, 0, 0, 0, 20, 99, 104, 97, 105, 110, 95, + 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 0, 0, 0, 18, + 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 11, 65, 112, 116, 111, 115, 83, 116, 100, 108, 105, 98, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 10, 77, 111, 118, 101, 83, 116, 100, 108, 105, + 98, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_20: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 119, 8, 218, 1, 64, 16, 154, 2, 31, 10, + 185, 2, 22, 12, 207, 2, 204, 2, 13, 155, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, + 99, 105, 101, 115, 95, 50, 48, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, + 117, 110, 116, 4, 68, 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, + 117, 114, 99, 101, 2, 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, + 103, 6, 115, 116, 114, 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, + 97, 95, 114, 101, 102, 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, + 8, 116, 111, 95, 98, 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, + 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, + 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, + 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, + 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, + 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, + 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, + 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, + 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, + 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, + 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, + 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, + 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, + 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, + 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, + 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, + 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, + 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, + 0, 4, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_19: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 141, 1, 8, 248, 1, 64, 16, 184, 2, 31, + 10, 215, 2, 22, 12, 237, 2, 207, 2, 13, 188, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 57, 7, 67, + 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, + 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, + 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, + 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, + 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, + 4, 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 50, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_18: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 141, 1, 8, 248, 1, 64, 16, 184, 2, 31, + 10, 215, 2, 22, 12, 237, 2, 207, 2, 13, 188, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 56, 7, 67, + 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, + 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, + 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, + 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, + 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, + 4, 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 49, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_17: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 141, 1, 8, 248, 1, 64, 16, 184, 2, 31, + 10, 215, 2, 22, 12, 237, 2, 207, 2, 13, 188, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 55, 7, 67, + 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, + 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, + 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, + 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, + 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, + 4, 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 49, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_16: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 141, 1, 8, 248, 1, 64, 16, 184, 2, 31, + 10, 215, 2, 22, 12, 237, 2, 207, 2, 13, 188, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 54, 7, 67, + 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, + 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, + 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, + 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, + 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, + 4, 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 49, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_15: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 141, 1, 8, 248, 1, 64, 16, 184, 2, 31, + 10, 215, 2, 22, 12, 237, 2, 207, 2, 13, 188, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 53, 7, 67, + 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, + 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, + 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, + 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, + 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, + 4, 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 49, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_14: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 141, 1, 8, 248, 1, 64, 16, 184, 2, 31, + 10, 215, 2, 22, 12, 237, 2, 207, 2, 13, 188, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 52, 7, 67, + 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, + 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, + 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, + 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, + 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, + 4, 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 49, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_13: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 141, 1, 8, 248, 1, 64, 16, 184, 2, 31, + 10, 215, 2, 22, 12, 237, 2, 207, 2, 13, 188, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 51, 7, 67, + 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, + 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, + 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, + 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, + 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, + 4, 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 49, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_12: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 141, 1, 8, 248, 1, 64, 16, 184, 2, 31, + 10, 215, 2, 22, 12, 237, 2, 207, 2, 13, 188, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 50, 7, 67, + 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, + 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, + 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, + 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, + 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, + 4, 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 49, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_11: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 141, 1, 8, 248, 1, 64, 16, 184, 2, 31, + 10, 215, 2, 22, 12, 237, 2, 207, 2, 13, 188, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 49, 7, 67, + 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, + 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, + 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, + 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, + 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, + 4, 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_10: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 141, 1, 8, 248, 1, 64, 16, 184, 2, 31, + 10, 215, 2, 22, 12, 237, 2, 207, 2, 13, 188, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 21, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 48, 7, 67, + 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, + 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, + 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, + 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, + 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, + 4, 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, + 101, 110, 99, 105, 101, 115, 95, 49, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_9: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 140, 1, 8, 247, 1, 64, 16, 183, 2, 31, + 10, 214, 2, 22, 12, 236, 2, 207, 2, 13, 187, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 20, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 57, 7, 67, 111, + 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, 100, + 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, 97, + 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, 99, + 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, 112, + 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, 4, + 110, 101, 120, 116, 21, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 49, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, + 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, + 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, + 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, + 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, + 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, + 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, + 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, + 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, + 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, + 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, + 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, + 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, + 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, + 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, + 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, + 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, + 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, + 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, + 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, 0, + 0, 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_8: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 139, 1, 8, 246, 1, 64, 16, 182, 2, 31, + 10, 213, 2, 22, 12, 235, 2, 207, 2, 13, 186, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 20, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 56, 7, 67, 111, + 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, 100, + 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, 97, + 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, 99, + 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, 112, + 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, 4, + 110, 101, 120, 116, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, + 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, + 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, + 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, + 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, + 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, + 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, + 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, + 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, + 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, + 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, + 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, + 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, + 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, + 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, + 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, + 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, + 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, + 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, + 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_7: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 139, 1, 8, 246, 1, 64, 16, 182, 2, 31, + 10, 213, 2, 22, 12, 235, 2, 207, 2, 13, 186, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 20, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 55, 7, 67, 111, + 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, 100, + 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, 97, + 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, 99, + 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, 112, + 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, 4, + 110, 101, 120, 116, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, + 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, + 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, + 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, + 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, + 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, + 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, + 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, + 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, + 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, + 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, + 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, + 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, + 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, + 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, + 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, + 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, + 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, + 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, + 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_6: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 139, 1, 8, 246, 1, 64, 16, 182, 2, 31, + 10, 213, 2, 22, 12, 235, 2, 207, 2, 13, 186, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 20, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 54, 7, 67, 111, + 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, 100, + 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, 97, + 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, 99, + 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, 112, + 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, 4, + 110, 101, 120, 116, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, + 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, + 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, + 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, + 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, + 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, + 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, + 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, + 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, + 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, + 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, + 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, + 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, + 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, + 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, + 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, + 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, + 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, + 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, + 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_5: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 139, 1, 8, 246, 1, 64, 16, 182, 2, 31, + 10, 213, 2, 22, 12, 235, 2, 207, 2, 13, 186, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 20, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 53, 7, 67, 111, + 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, 100, + 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, 97, + 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, 99, + 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, 112, + 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, 4, + 110, 101, 120, 116, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, + 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, + 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, + 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, + 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, + 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, + 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, + 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, + 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, + 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, + 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, + 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, + 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, + 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, + 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, + 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, + 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, + 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, + 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, + 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_4: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 139, 1, 8, 246, 1, 64, 16, 182, 2, 31, + 10, 213, 2, 22, 12, 235, 2, 207, 2, 13, 186, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 20, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 52, 7, 67, 111, + 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, 100, + 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, 97, + 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, 99, + 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, 112, + 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, 4, + 110, 101, 120, 116, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, + 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, + 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, + 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, + 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, + 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, + 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, + 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, + 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, + 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, + 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, + 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, + 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, + 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, + 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, + 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, + 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, + 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, + 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, + 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_3: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 139, 1, 8, 246, 1, 64, 16, 182, 2, 31, + 10, 213, 2, 22, 12, 235, 2, 207, 2, 13, 186, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 20, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 51, 7, 67, 111, + 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, 100, + 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, 97, + 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, 99, + 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, 112, + 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, 4, + 110, 101, 120, 116, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, + 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, + 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, + 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, + 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, + 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, + 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, + 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, + 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, + 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, + 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, + 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, + 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, + 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, + 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, + 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, + 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, + 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, + 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, + 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_2: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 139, 1, 8, 246, 1, 64, 16, 182, 2, 31, + 10, 213, 2, 22, 12, 235, 2, 207, 2, 13, 186, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 20, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 50, 7, 67, 111, + 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, 100, + 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, 97, + 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, 99, + 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, 112, + 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, 4, + 110, 101, 120, 116, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, + 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, + 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, + 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, + 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, + 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, + 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, + 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, + 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, + 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, + 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, + 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, + 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, + 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, + 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, + 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, + 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, + 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, + 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, + 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_1: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 8, 2, 8, 16, 3, 24, 31, + 4, 55, 2, 5, 57, 50, 7, 107, 139, 1, 8, 246, 1, 64, 16, 182, 2, 31, + 10, 213, 2, 22, 12, 235, 2, 207, 2, 13, 186, 5, 4, 0, 0, 1, 9, 1, + 12, 0, 15, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, + 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, + 0, 1, 0, 14, 4, 5, 0, 1, 3, 14, 4, 5, 0, 1, 2, 6, 4, 6, + 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, 1, 6, 3, 4, 6, 3, 6, + 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, 1, 10, 3, 1, 6, 9, 0, + 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, 2, 20, 99, 104, 97, 105, 110, + 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 95, 49, 7, 67, 111, + 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, 4, 100, + 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, 110, 97, + 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, 14, 99, + 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, 111, 112, + 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, 4, + 110, 101, 120, 116, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, + 110, 99, 105, 101, 115, 95, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, + 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, + 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, + 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, + 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, + 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, + 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, + 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, + 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, + 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, + 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, + 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, + 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, + 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, + 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, + 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, + 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, + 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, + 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, + 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, + 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 4, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 17, 4, 22, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 7, 1, 0, 4, 3, 4, 12, 5, 16, 3, + 7, 19, 49, 8, 68, 32, 16, 100, 31, 12, 131, 1, 31, 0, 0, 0, 2, 0, + 1, 0, 0, 0, 1, 1, 3, 0, 1, 0, 1, 0, 1, 3, 18, 99, 104, 97, + 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, 101, 115, 3, 114, 117, + 110, 20, 99, 104, 97, 105, 110, 95, 100, 101, 112, 101, 110, 100, 101, 110, 99, 105, + 101, 115, 95, 49, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, + 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, + 0, 1, 4, 0, 0, 7, 17, 1, 6, 20, 0, 0, 0, 0, 0, 0, 0, 33, + 4, 5, 2, 6, 77, 0, 0, 0, 0, 0, 0, 0, 39, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULES_MODULE_LOADING_CHAIN_DEPENDENCIES: Lazy>> = Lazy::new(|| { vec![ + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_20.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_19.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_18.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_17.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_16.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_15.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_14.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_13.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_12.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_11.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_10.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_9.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_8.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_7.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_6.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_5.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_4.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_3.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_2.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES_1.to_vec(), + MODULE_MODULE_LOADING_CHAIN_DEPENDENCIES_CHAIN_DEPENDENCIES.to_vec(), +]}); + #[rustfmt::skip] pub static PACKAGE_COMPLEX_METADATA: Lazy> = Lazy::new(|| { vec![ @@ -735,14 +2850,1024 @@ pub static MODULES_COMPLEX: Lazy>> = Lazy::new(|| { vec![ MODULE_COMPLEX_VECTOR_PICTURE.to_vec(), ]}); +#[rustfmt::skip] +pub static PACKAGE_MODULE_LOADING_CHAIN_FRIENDS_METADATA: Lazy> = Lazy::new(|| { + vec![ + 28, 109, 111, 100, 117, 108, 101, 95, 108, 111, 97, 100, 105, 110, 103, 95, 99, 104, + 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 64, 56, 52, 57, 52, 57, 65, 49, 56, 67, 56, 68, 67, 55, 66, 69, + 67, 69, 69, 56, 51, 66, 56, 53, 48, 70, 68, 53, 68, 50, 51, 69, 57, 48, + 69, 65, 50, 66, 54, 51, 56, 65, 48, 52, 56, 55, 54, 55, 53, 52, 67, 54, + 54, 65, 50, 54, 55, 55, 51, 54, 50, 53, 54, 51, 69, 173, 1, 31, 139, 8, + 0, 0, 0, 0, 0, 2, 255, 77, 141, 49, 14, 131, 48, 12, 69, 247, 156, 34, + 98, 97, 106, 160, 7, 232, 64, 219, 27, 116, 68, 40, 50, 137, 129, 136, 144, 68, + 49, 208, 74, 85, 239, 222, 164, 98, 168, 228, 193, 250, 126, 126, 191, 13, 160, 102, + 24, 177, 99, 14, 22, 228, 23, 94, 46, 94, 111, 22, 165, 245, 160, 141, 27, 165, + 154, 192, 56, 57, 68, 131, 78, 83, 201, 118, 140, 100, 188, 203, 224, 89, 212, 162, + 46, 25, 107, 53, 134, 116, 68, 167, 12, 82, 199, 154, 176, 122, 122, 172, 218, 154, + 62, 81, 111, 110, 189, 2, 155, 182, 66, 136, 234, 127, 32, 115, 167, 197, 239, 88, + 13, 49, 117, 63, 125, 156, 143, 144, 126, 223, 5, 255, 36, 57, 104, 29, 145, 40, + 155, 195, 214, 91, 67, 19, 70, 121, 132, 217, 90, 191, 154, 235, 237, 94, 176, 47, + 31, 68, 110, 190, 201, 0, 0, 0, 21, 13, 99, 104, 97, 105, 110, 95, 102, 114, + 105, 101, 110, 100, 115, 0, 0, 0, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, + 101, 110, 100, 115, 95, 49, 0, 0, 0, 15, 99, 104, 97, 105, 110, 95, 102, 114, + 105, 101, 110, 100, 115, 95, 50, 0, 0, 0, 15, 99, 104, 97, 105, 110, 95, 102, + 114, 105, 101, 110, 100, 115, 95, 51, 0, 0, 0, 15, 99, 104, 97, 105, 110, 95, + 102, 114, 105, 101, 110, 100, 115, 95, 52, 0, 0, 0, 15, 99, 104, 97, 105, 110, + 95, 102, 114, 105, 101, 110, 100, 115, 95, 53, 0, 0, 0, 15, 99, 104, 97, 105, + 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 54, 0, 0, 0, 15, 99, 104, 97, + 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 55, 0, 0, 0, 15, 99, 104, + 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 56, 0, 0, 0, 15, 99, + 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 57, 0, 0, 0, 16, + 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 48, 0, 0, + 0, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 49, + 0, 0, 0, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, + 49, 50, 0, 0, 0, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, + 115, 95, 49, 51, 0, 0, 0, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, + 110, 100, 115, 95, 49, 52, 0, 0, 0, 16, 99, 104, 97, 105, 110, 95, 102, 114, + 105, 101, 110, 100, 115, 95, 49, 53, 0, 0, 0, 16, 99, 104, 97, 105, 110, 95, + 102, 114, 105, 101, 110, 100, 115, 95, 49, 54, 0, 0, 0, 16, 99, 104, 97, 105, + 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 55, 0, 0, 0, 16, 99, 104, + 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 56, 0, 0, 0, 16, + 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 57, 0, 0, + 0, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 50, 48, + 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 11, 65, 112, 116, 111, 115, 83, 116, 100, 108, 105, 98, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 1, 10, 77, 111, 118, 101, 83, 116, 100, 108, 105, + 98, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 8, 1, 0, 2, 3, 2, 6, 5, 8, 1, + 7, 9, 34, 8, 43, 32, 16, 75, 31, 12, 106, 7, 15, 113, 2, 0, 0, 0, + 1, 0, 0, 0, 1, 0, 13, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, + 100, 115, 3, 114, 117, 110, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, + 100, 115, 95, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, + 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, + 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 1, 4, 0, 0, + 1, 2, 0, 2, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_1: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 124, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 188, 2, 13, 138, 5, 4, 15, 142, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 7, + 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, + 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, + 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, + 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, + 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, + 115, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 50, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, + 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, + 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, + 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, + 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, + 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, + 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, + 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, + 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, + 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, + 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, + 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, + 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, + 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, + 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, + 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_2: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 124, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 188, 2, 13, 138, 5, 4, 15, 142, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 50, 7, + 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, + 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, + 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, + 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, + 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, + 115, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 51, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, + 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, + 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, + 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, + 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, + 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, + 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, + 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, + 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, + 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, + 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, + 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, + 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, + 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, + 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, + 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_3: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 124, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 188, 2, 13, 138, 5, 4, 15, 142, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 51, 7, + 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, + 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, + 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, + 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, + 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, + 115, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 52, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, + 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, + 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, + 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, + 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, + 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, + 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, + 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, + 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, + 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, + 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, + 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, + 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, + 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, + 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, + 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_4: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 124, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 188, 2, 13, 138, 5, 4, 15, 142, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 52, 7, + 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, + 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, + 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, + 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, + 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, + 115, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 53, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, + 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, + 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, + 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, + 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, + 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, + 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, + 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, + 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, + 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, + 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, + 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, + 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, + 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, + 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, + 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_5: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 124, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 188, 2, 13, 138, 5, 4, 15, 142, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 53, 7, + 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, + 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, + 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, + 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, + 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, + 115, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 54, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, + 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, + 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, + 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, + 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, + 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, + 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, + 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, + 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, + 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, + 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, + 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, + 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, + 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, + 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, + 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_6: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 124, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 188, 2, 13, 138, 5, 4, 15, 142, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 54, 7, + 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, + 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, + 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, + 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, + 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, + 115, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 55, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, + 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, + 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, + 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, + 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, + 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, + 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, + 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, + 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, + 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, + 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, + 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, + 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, + 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, + 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, + 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_7: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 124, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 188, 2, 13, 138, 5, 4, 15, 142, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 55, 7, + 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, + 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, + 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, + 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, + 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, + 115, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 56, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, + 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, + 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, + 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, + 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, + 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, + 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, + 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, + 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, + 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, + 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, + 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, + 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, + 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, + 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, + 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_8: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 124, 8, 217, 1, 64, 16, 153, 2, 31, 10, + 184, 2, 22, 12, 206, 2, 188, 2, 13, 138, 5, 4, 15, 142, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 56, 7, + 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, + 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, + 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, + 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, + 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, + 115, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 57, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, + 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, + 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, + 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, + 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, + 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, + 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, + 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, + 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, + 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, + 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, + 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, + 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, + 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, + 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, + 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, + 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, + 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, + 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_9: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 125, 8, 218, 1, 64, 16, 154, 2, 31, 10, + 185, 2, 22, 12, 207, 2, 188, 2, 13, 139, 5, 4, 15, 143, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 15, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 57, 7, + 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, 97, + 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, 4, + 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, 103, + 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, 111, + 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, + 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 48, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, + 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, + 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, 2, + 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, 16, + 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, 92, + 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, 20, + 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, 12, + 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, 5, + 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, 12, + 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, 5, + 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, 34, + 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, 0, + 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, 16, + 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, 64, + 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, 11, + 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, 0, + 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, 22, + 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, 18, + 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_10: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 126, 8, 219, 1, 64, 16, 155, 2, 31, 10, + 186, 2, 22, 12, 208, 2, 188, 2, 13, 140, 5, 4, 15, 144, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 48, + 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, + 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, + 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, + 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, + 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, + 101, 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, + 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, + 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, + 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, + 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, + 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, + 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, + 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, + 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, + 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, + 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, + 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, + 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, + 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, + 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, + 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, + 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, + 18, 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_11: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 126, 8, 219, 1, 64, 16, 155, 2, 31, 10, + 186, 2, 22, 12, 208, 2, 188, 2, 13, 140, 5, 4, 15, 144, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 49, + 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, + 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, + 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, + 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, + 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, + 101, 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, + 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, + 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, + 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, + 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, + 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, + 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, + 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, + 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, + 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, + 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, + 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, + 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, + 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, + 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, + 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, + 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, + 18, 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_12: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 126, 8, 219, 1, 64, 16, 155, 2, 31, 10, + 186, 2, 22, 12, 208, 2, 188, 2, 13, 140, 5, 4, 15, 144, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 50, + 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, + 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, + 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, + 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, + 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, + 101, 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, + 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, + 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, + 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, + 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, + 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, + 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, + 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, + 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, + 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, + 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, + 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, + 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, + 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, + 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, + 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, + 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, + 18, 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_13: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 126, 8, 219, 1, 64, 16, 155, 2, 31, 10, + 186, 2, 22, 12, 208, 2, 188, 2, 13, 140, 5, 4, 15, 144, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 51, + 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, + 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, + 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, + 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, + 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, + 101, 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, + 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, + 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, + 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, + 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, + 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, + 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, + 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, + 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, + 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, + 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, + 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, + 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, + 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, + 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, + 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, + 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, + 18, 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_14: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 126, 8, 219, 1, 64, 16, 155, 2, 31, 10, + 186, 2, 22, 12, 208, 2, 188, 2, 13, 140, 5, 4, 15, 144, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 52, + 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, + 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, + 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, + 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, + 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, + 101, 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, + 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, + 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, + 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, + 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, + 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, + 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, + 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, + 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, + 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, + 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, + 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, + 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, + 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, + 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, + 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, + 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, + 18, 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_15: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 126, 8, 219, 1, 64, 16, 155, 2, 31, 10, + 186, 2, 22, 12, 208, 2, 188, 2, 13, 140, 5, 4, 15, 144, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 53, + 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, + 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, + 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, + 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, + 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, + 101, 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, + 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, + 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, + 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, + 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, + 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, + 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, + 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, + 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, + 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, + 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, + 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, + 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, + 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, + 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, + 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, + 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, + 18, 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_16: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 126, 8, 219, 1, 64, 16, 155, 2, 31, 10, + 186, 2, 22, 12, 208, 2, 188, 2, 13, 140, 5, 4, 15, 144, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 54, + 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, + 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, + 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, + 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, + 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, + 101, 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, + 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, + 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, + 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, + 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, + 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, + 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, + 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, + 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, + 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, + 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, + 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, + 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, + 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, + 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, + 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, + 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, + 18, 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_17: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 126, 8, 219, 1, 64, 16, 155, 2, 31, 10, + 186, 2, 22, 12, 208, 2, 188, 2, 13, 140, 5, 4, 15, 144, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 55, + 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, + 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, + 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, + 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, + 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, + 101, 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, + 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, + 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, + 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, + 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, + 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, + 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, + 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, + 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, + 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, + 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, + 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, + 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, + 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, + 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, + 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, + 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, + 18, 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_18: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 126, 8, 219, 1, 64, 16, 155, 2, 31, 10, + 186, 2, 22, 12, 208, 2, 188, 2, 13, 140, 5, 4, 15, 144, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 56, + 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, + 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, + 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, + 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, + 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, + 101, 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, + 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, + 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, + 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, + 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, + 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, + 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, + 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, + 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, + 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, + 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, + 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, + 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, + 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, + 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, + 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, + 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, + 18, 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_19: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 12, 1, 0, 6, 2, 6, 16, 3, 22, 19, + 4, 41, 2, 5, 43, 50, 7, 93, 126, 8, 219, 1, 64, 16, 155, 2, 31, 10, + 186, 2, 22, 12, 208, 2, 188, 2, 13, 140, 5, 4, 15, 144, 5, 2, 0, 0, + 1, 9, 1, 12, 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, + 7, 0, 0, 10, 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, + 1, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, 8, 0, + 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, 1, 3, + 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, 3, 10, + 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 49, 57, + 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, 97, 116, + 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, 105, 100, + 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, 105, 110, + 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, 8, 108, + 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, 121, 116, + 101, 115, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, 50, + 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 171, 205, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, + 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, + 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, 3, 1, 2, 1, 4, 10, 2, 2, + 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, 0, 1, 0, 0, 2, 101, 10, 0, + 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, 11, 4, 20, 10, 5, 20, 35, 4, + 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, 5, 10, 5, 20, 10, 1, 16, 0, + 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, 11, 2, 1, 11, 4, 1, 11, 5, + 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, 20, 10, 5, 20, 35, 4, 62, 11, + 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, 33, 4, 57, 11, 5, 1, 11, 4, + 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, 12, 7, 5, 55, 11, 4, 1, 10, + 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, 16, 0, 12, 7, 10, 4, 11, 7, + 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, 2, 16, 1, 12, 4, 11, 1, 16, + 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, 1, 5, 37, 11, 5, 1, 10, 1, + 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, 5, 17, 1, 1, 0, 0, 10, 43, + 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, 4, 16, 13, 2, 10, 3, 68, 5, + 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 3, 5, 4, 6, 0, + 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, 0, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, 5, 11, 1, 12, 3, 14, 5, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, 20, 52, 12, 4, 11, 3, 11, 4, + 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 0, 5, + 18, 2, 2, 0, 0, 0, 0, 14, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_20: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 11, 1, 0, 6, 2, 6, 16, 3, 22, 25, + 4, 47, 2, 5, 49, 50, 7, 99, 114, 8, 213, 1, 64, 16, 149, 2, 31, 10, + 180, 2, 22, 12, 202, 2, 204, 2, 13, 150, 5, 4, 0, 0, 1, 9, 1, 12, + 0, 1, 8, 0, 0, 3, 7, 0, 0, 5, 8, 0, 1, 8, 7, 0, 0, 10, + 0, 1, 0, 1, 0, 11, 3, 4, 0, 1, 2, 13, 7, 8, 1, 0, 1, 0, + 14, 4, 5, 0, 1, 2, 6, 4, 6, 8, 2, 6, 8, 2, 6, 8, 0, 6, + 8, 0, 1, 6, 3, 4, 6, 3, 6, 3, 6, 3, 6, 3, 2, 3, 3, 0, + 1, 3, 1, 10, 3, 1, 6, 9, 0, 1, 10, 2, 1, 2, 4, 10, 3, 3, + 3, 10, 2, 16, 99, 104, 97, 105, 110, 95, 102, 114, 105, 101, 110, 100, 115, 95, + 50, 48, 7, 67, 111, 117, 110, 116, 101, 114, 5, 99, 111, 117, 110, 116, 4, 68, + 97, 116, 97, 4, 100, 97, 116, 97, 8, 82, 101, 115, 111, 117, 114, 99, 101, 2, + 105, 100, 4, 110, 97, 109, 101, 6, 83, 116, 114, 105, 110, 103, 6, 115, 116, 114, + 105, 110, 103, 14, 99, 111, 112, 121, 95, 112, 97, 115, 116, 97, 95, 114, 101, 102, + 8, 108, 111, 111, 112, 95, 98, 99, 115, 3, 98, 99, 115, 8, 116, 111, 95, 98, + 121, 116, 101, 115, 4, 110, 101, 120, 116, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 171, 205, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, 116, 97, + 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 2, 1, 2, + 3, 1, 2, 1, 4, 10, 2, 2, 2, 3, 6, 3, 7, 8, 3, 4, 8, 1, + 0, 1, 0, 0, 2, 101, 10, 0, 16, 0, 12, 4, 10, 1, 16, 0, 12, 5, + 11, 4, 20, 10, 5, 20, 35, 4, 92, 11, 5, 12, 4, 10, 2, 16, 1, 12, + 5, 10, 5, 20, 10, 1, 16, 0, 20, 35, 4, 67, 11, 0, 1, 11, 1, 1, + 11, 2, 1, 11, 4, 1, 11, 5, 12, 4, 11, 3, 16, 1, 12, 5, 10, 4, + 20, 10, 5, 20, 35, 4, 62, 11, 5, 1, 10, 4, 12, 5, 10, 4, 10, 5, + 33, 4, 57, 11, 5, 1, 11, 4, 12, 7, 11, 7, 2, 11, 4, 1, 11, 5, + 12, 7, 5, 55, 11, 4, 1, 10, 5, 12, 4, 5, 47, 11, 3, 1, 11, 0, + 16, 0, 12, 7, 10, 4, 11, 7, 34, 4, 87, 11, 4, 1, 11, 5, 1, 11, + 2, 16, 1, 12, 4, 11, 1, 16, 0, 12, 5, 5, 37, 11, 1, 1, 11, 2, + 1, 5, 37, 11, 5, 1, 10, 1, 16, 0, 12, 4, 10, 3, 16, 1, 12, 5, + 5, 17, 1, 1, 0, 0, 10, 43, 64, 5, 0, 0, 0, 0, 0, 0, 0, 0, + 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 3, 10, 1, 35, + 4, 16, 13, 2, 10, 3, 68, 5, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, + 0, 22, 12, 3, 5, 4, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 1, 10, + 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 42, 14, 2, 56, 0, 12, + 5, 11, 1, 12, 3, 14, 5, 6, 0, 0, 0, 0, 0, 0, 0, 0, 66, 9, + 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 1, 11, 0, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 0, 5, 18, 2, 3, 1, 0, 0, 4, 2, 6, 1, + 0, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0, 0, + ] +}); + +#[rustfmt::skip] +pub static MODULES_MODULE_LOADING_CHAIN_FRIENDS: Lazy>> = Lazy::new(|| { vec![ + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_1.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_2.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_3.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_4.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_5.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_6.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_7.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_8.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_9.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_10.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_11.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_12.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_13.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_14.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_15.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_16.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_17.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_18.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_19.to_vec(), + MODULE_MODULE_LOADING_CHAIN_FRIENDS_CHAIN_FRIENDS_20.to_vec(), +]}); + #[rustfmt::skip] pub static PACKAGE_SIMPLE_METADATA: Lazy> = Lazy::new(|| { vec![ 13, 71, 101, 110, 101, 114, 105, 99, 77, 111, 100, 117, 108, 101, 1, 0, 0, 0, - 0, 0, 0, 0, 0, 64, 69, 53, 53, 57, 68, 57, 51, 68, 67, 55, 70, 65, - 56, 70, 70, 66, 70, 53, 70, 65, 57, 48, 49, 52, 57, 69, 49, 65, 56, 48, - 56, 55, 57, 67, 65, 52, 56, 50, 66, 67, 52, 67, 48, 50, 48, 51, 51, 50, - 53, 53, 52, 67, 50, 67, 48, 52, 49, 56, 67, 54, 56, 56, 53, 69, 132, 1, + 0, 0, 0, 0, 0, 64, 57, 66, 56, 48, 68, 66, 66, 50, 48, 57, 69, 66, + 57, 49, 51, 54, 51, 56, 57, 55, 51, 65, 50, 67, 48, 67, 52, 70, 52, 67, + 51, 54, 69, 50, 49, 52, 48, 48, 57, 70, 56, 66, 53, 70, 68, 68, 53, 68, + 69, 51, 48, 65, 49, 54, 55, 67, 67, 66, 49, 57, 68, 55, 70, 68, 132, 1, 31, 139, 8, 0, 0, 0, 0, 0, 2, 255, 77, 139, 59, 14, 194, 48, 16, 68, 251, 61, 133, 229, 30, 135, 11, 80, 208, 64, 197, 9, 162, 20, 43, 123, 64, 86, 156, 93, 203, 134, 80, 32, 238, 142, 45, 1, 138, 102, 154, 249, 188, 49, 179, 159, @@ -762,16 +3887,6 @@ pub static PACKAGE_SIMPLE_METADATA: Lazy> = Lazy::new(|| { ] }); -#[rustfmt::skip] -pub static SCRIPT_SIMPLE: Lazy> = Lazy::new(|| { - vec![ - 161, 28, 235, 11, 7, 0, 0, 10, 2, 5, 0, 4, 6, 4, 34, 1, 6, 12, - 0, 5, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, - 0, 1, 3, 11, 0, 1, 2, - ] -}); - #[rustfmt::skip] pub static MODULE_SIMPLE_SIMPLE: Lazy> = Lazy::new(|| { vec![ @@ -975,6 +4090,47 @@ pub static MODULE_SIMPLE_SIMPLE: Lazy> = Lazy::new(|| { ] }); +#[rustfmt::skip] +pub static SCRIPT_SIMPLE: Lazy> = Lazy::new(|| { + vec![ + 161, 28, 235, 11, 7, 0, 0, 10, 7, 1, 0, 2, 3, 2, 7, 4, 9, 2, + 5, 11, 32, 7, 43, 27, 8, 70, 64, 16, 134, 1, 31, 1, 2, 0, 3, 4, + 5, 1, 0, 1, 0, 3, 1, 6, 12, 0, 1, 3, 1, 10, 3, 1, 6, 9, + 0, 1, 10, 2, 1, 2, 11, 3, 3, 3, 3, 3, 3, 1, 1, 1, 10, 3, + 10, 2, 8, 60, 83, 69, 76, 70, 62, 95, 48, 4, 109, 97, 105, 110, 3, 98, + 99, 115, 8, 116, 111, 95, 98, 121, 116, 101, 115, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 20, 99, 111, 109, 112, 105, 108, 97, 116, 105, 111, 110, 95, 109, 101, + 116, 97, 100, 97, 116, 97, 9, 0, 3, 50, 46, 48, 3, 50, 46, 49, 0, 0, + 7, 139, 1, 6, 23, 0, 0, 0, 0, 0, 0, 0, 12, 1, 11, 0, 1, 10, + 1, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 13, 11, 1, 6, 1, 0, + 0, 0, 0, 0, 0, 0, 23, 12, 1, 5, 4, 6, 0, 0, 0, 0, 0, 0, + 0, 0, 12, 2, 6, 0, 0, 0, 0, 0, 0, 0, 0, 12, 3, 10, 1, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 86, 11, 1, 6, 1, 0, 0, 0, + 0, 0, 0, 0, 23, 12, 1, 11, 2, 6, 1, 0, 0, 0, 0, 0, 0, 0, + 22, 12, 4, 11, 3, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 5, 10, + 4, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 11, 4, 23, 12, 3, 10, 5, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 10, 5, 23, 12, 4, 10, 4, 6, + 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 2, 10, 4, 10, 2, 36, 4, 83, + 10, 2, 10, 5, 36, 12, 7, 11, 7, 4, 80, 11, 5, 10, 3, 36, 12, 8, + 11, 8, 4, 77, 10, 3, 11, 4, 36, 12, 9, 11, 9, 3, 72, 5, 17, 11, + 1, 6, 1, 0, 0, 0, 0, 0, 0, 0, 22, 12, 1, 5, 17, 9, 12, 9, + 5, 69, 9, 12, 8, 5, 63, 9, 12, 7, 5, 57, 6, 5, 0, 0, 0, 0, + 0, 0, 0, 12, 1, 64, 2, 0, 0, 0, 0, 0, 0, 0, 0, 12, 10, 6, + 0, 0, 0, 0, 0, 0, 0, 0, 12, 2, 10, 2, 6, 20, 0, 0, 0, 0, + 0, 0, 0, 35, 4, 104, 13, 10, 10, 2, 68, 2, 11, 2, 6, 1, 0, 0, + 0, 0, 0, 0, 0, 22, 12, 2, 5, 92, 6, 0, 0, 0, 0, 0, 0, 0, + 0, 12, 2, 10, 1, 6, 0, 0, 0, 0, 0, 0, 0, 0, 36, 4, 130, 1, + 14, 10, 56, 0, 12, 11, 11, 2, 12, 3, 14, 11, 6, 0, 0, 0, 0, 0, + 0, 0, 0, 66, 6, 20, 52, 12, 4, 11, 3, 11, 4, 22, 12, 2, 11, 1, + 6, 1, 0, 0, 0, 0, 0, 0, 0, 23, 12, 1, 5, 106, 11, 1, 6, 64, + 66, 15, 0, 0, 0, 0, 0, 33, 4, 135, 1, 5, 136, 1, 5, 138, 1, 5, + 136, 1, 5, 138, 1, 2, + ] +}); + #[rustfmt::skip] pub static MODULES_SIMPLE: Lazy>> = Lazy::new(|| { vec![ MODULE_SIMPLE_SIMPLE.to_vec(), @@ -2159,7 +5315,10 @@ pub static MODULES_BCS_STREAM: Lazy>> = Lazy::new(|| { vec![ #[rustfmt::skip] pub static PACKAGE_TO_METADATA: Lazy>> = Lazy::new(|| { HashMap::from([ + ("module_loading_star_dependencies".to_string(), PACKAGE_MODULE_LOADING_STAR_DEPENDENCIES_METADATA.to_vec()), + ("module_loading_chain_dependencies".to_string(), PACKAGE_MODULE_LOADING_CHAIN_DEPENDENCIES_METADATA.to_vec()), ("complex".to_string(), PACKAGE_COMPLEX_METADATA.to_vec()), + ("module_loading_chain_friends".to_string(), PACKAGE_MODULE_LOADING_CHAIN_FRIENDS_METADATA.to_vec()), ("simple".to_string(), PACKAGE_SIMPLE_METADATA.to_vec()), ("framework_usecases".to_string(), PACKAGE_FRAMEWORK_USECASES_METADATA.to_vec()), ("ambassador_token".to_string(), PACKAGE_AMBASSADOR_TOKEN_METADATA.to_vec()), @@ -2169,7 +5328,10 @@ pub static PACKAGE_TO_METADATA: Lazy>> = Lazy::new(|| { #[rustfmt::skip] pub static PACKAGE_TO_MODULES: Lazy>>> = Lazy::new(|| { HashMap::from([ + ("module_loading_star_dependencies".to_string(), MODULES_MODULE_LOADING_STAR_DEPENDENCIES.to_vec()), + ("module_loading_chain_dependencies".to_string(), MODULES_MODULE_LOADING_CHAIN_DEPENDENCIES.to_vec()), ("complex".to_string(), MODULES_COMPLEX.to_vec()), + ("module_loading_chain_friends".to_string(), MODULES_MODULE_LOADING_CHAIN_FRIENDS.to_vec()), ("simple".to_string(), MODULES_SIMPLE.to_vec()), ("framework_usecases".to_string(), MODULES_FRAMEWORK_USECASES.to_vec()), ("ambassador_token".to_string(), MODULES_AMBASSADOR_TOKEN.to_vec()), diff --git a/execution/executor-benchmark/src/native_executor.rs b/execution/executor-benchmark/src/native_executor.rs index f90eb1498f79e..38e1b08b4c393 100644 --- a/execution/executor-benchmark/src/native_executor.rs +++ b/execution/executor-benchmark/src/native_executor.rs @@ -6,6 +6,7 @@ use crate::{ metrics::TIMER, }; use anyhow::Result; +use aptos_crypto::HashValue; use aptos_types::{ account_address::AccountAddress, account_config::{DepositEvent, WithdrawEvent}, @@ -359,6 +360,8 @@ impl VMBlockExecutor for NativeExecutor { transactions: &[SignatureVerifiedTransaction], state_view: &(impl StateView + Sync), _onchain_config: BlockExecutorConfigFromOnchain, + _parent_block: Option<&HashValue>, + _current_block: Option, ) -> Result, VMStatus> { let transaction_outputs = NATIVE_EXECUTOR_POOL .install(|| { diff --git a/execution/executor/Cargo.toml b/execution/executor/Cargo.toml index fcc3213c594bb..7fc27599e38fd 100644 --- a/execution/executor/Cargo.toml +++ b/execution/executor/Cargo.toml @@ -50,7 +50,7 @@ aptos-executor-test-helpers = { workspace = true } aptos-genesis = { workspace = true } aptos-storage-interface = { workspace = true } aptos-temppath = { workspace = true } -aptos-types = { workspace = true } +aptos-types = { workspace = true, features = ["testing"] } aptos-vm-genesis = { workspace = true } proptest = { workspace = true } rand = { workspace = true } diff --git a/execution/executor/src/block_executor/mod.rs b/execution/executor/src/block_executor/mod.rs index 553804df81d68..45738dd6ca6a5 100644 --- a/execution/executor/src/block_executor/mod.rs +++ b/execution/executor/src/block_executor/mod.rs @@ -237,6 +237,7 @@ where transactions, state_view, onchain_config.clone(), + Some(&parent_block_id), Some(block_id), )? }; diff --git a/execution/executor/src/chunk_executor/mod.rs b/execution/executor/src/chunk_executor/mod.rs index 26391ae28acd6..55c8e005ede28 100644 --- a/execution/executor/src/chunk_executor/mod.rs +++ b/execution/executor/src/chunk_executor/mod.rs @@ -604,6 +604,7 @@ impl ChunkExecutorInner { state_view, BlockExecutorConfigFromOnchain::new_no_block_limit(), None, + None, )?; // not `zip_eq`, deliberately for (version, txn_out, txn_info, write_set, events) in multizip(( diff --git a/execution/executor/src/chunk_executor/transaction_chunk.rs b/execution/executor/src/chunk_executor/transaction_chunk.rs index 26f873162eb61..46d84d4fc1ae1 100644 --- a/execution/executor/src/chunk_executor/transaction_chunk.rs +++ b/execution/executor/src/chunk_executor/transaction_chunk.rs @@ -89,6 +89,7 @@ impl TransactionChunk for ChunkToExecute { state_view, BlockExecutorConfigFromOnchain::new_no_block_limit(), None, + None, ) } } diff --git a/execution/executor/src/db_bootstrapper/mod.rs b/execution/executor/src/db_bootstrapper/mod.rs index 1d9a3c2742cc8..ccb6bc6195014 100644 --- a/execution/executor/src/db_bootstrapper/mod.rs +++ b/execution/executor/src/db_bootstrapper/mod.rs @@ -137,6 +137,7 @@ pub fn calculate_genesis( base_state_view, BlockExecutorConfigFromOnchain::new_no_block_limit(), None, + None, )?; ensure!( execution_output.num_transactions_to_commit() != 0, diff --git a/execution/executor/src/fuzzing.rs b/execution/executor/src/fuzzing.rs index 67639b5831107..d73e272557dab 100644 --- a/execution/executor/src/fuzzing.rs +++ b/execution/executor/src/fuzzing.rs @@ -79,6 +79,8 @@ impl VMBlockExecutor for FakeVM { _transactions: &[SignatureVerifiedTransaction], _state_view: &impl StateView, _onchain_config: BlockExecutorConfigFromOnchain, + _parent_block: Option<&HashValue>, + _current_block: Option, ) -> Result, VMStatus> { Ok(BlockOutput::new(vec![], None)) } diff --git a/execution/executor/src/tests/mock_vm/mock_vm_test.rs b/execution/executor/src/tests/mock_vm/mock_vm_test.rs index 9481ac37aeba5..4df0ef06d0665 100644 --- a/execution/executor/src/tests/mock_vm/mock_vm_test.rs +++ b/execution/executor/src/tests/mock_vm/mock_vm_test.rs @@ -6,10 +6,7 @@ use super::{balance_ap, encode_mint_transaction, encode_transfer_transaction, se use aptos_types::{ account_address::AccountAddress, bytes::NumToBytes, - state_store::{ - state_key::StateKey, state_storage_usage::StateStorageUsage, state_value::StateValue, - Result, TStateView, - }, + state_store::{state_key::StateKey, MockStateView}, transaction::signature_verified_transaction::into_signature_verified_block, write_set::WriteOp, }; @@ -20,20 +17,6 @@ fn gen_address(index: u8) -> AccountAddress { AccountAddress::new([index; AccountAddress::LENGTH]) } -struct MockStateView; - -impl TStateView for MockStateView { - type Key = StateKey; - - fn get_state_value(&self, _state_key: &StateKey) -> Result> { - Ok(None) - } - - fn get_usage(&self) -> Result { - Ok(StateStorageUsage::new_untracked()) - } -} - #[test] fn test_mock_vm_different_senders() { let amount = 100; @@ -42,8 +25,11 @@ fn test_mock_vm_different_senders() { txns.push(encode_mint_transaction(gen_address(i), amount)); } - let outputs = MockVM - .execute_block_no_limit(&into_signature_verified_block(txns.clone()), &MockStateView) + let outputs = MockVM::new() + .execute_block_no_limit( + &into_signature_verified_block(txns.clone()), + &MockStateView::empty(), + ) .expect("MockVM should not fail to start"); for (output, txn) in itertools::zip_eq(outputs.iter(), txns.iter()) { @@ -79,8 +65,11 @@ fn test_mock_vm_same_sender() { txns.push(encode_mint_transaction(sender, amount)); } - let outputs = MockVM - .execute_block_no_limit(&into_signature_verified_block(txns), &MockStateView) + let outputs = MockVM::new() + .execute_block_no_limit( + &into_signature_verified_block(txns), + &MockStateView::empty(), + ) .expect("MockVM should not fail to start"); for (i, output) in outputs.iter().enumerate() { @@ -114,8 +103,11 @@ fn test_mock_vm_payment() { encode_transfer_transaction(gen_address(0), gen_address(1), 50), ]; - let output = MockVM - .execute_block_no_limit(&into_signature_verified_block(txns), &MockStateView) + let output = MockVM::new() + .execute_block_no_limit( + &into_signature_verified_block(txns), + &MockStateView::empty(), + ) .expect("MockVM should not fail to start"); let mut output_iter = output.iter(); diff --git a/execution/executor/src/tests/mock_vm/mod.rs b/execution/executor/src/tests/mock_vm/mod.rs index b72f1d7270e62..701c2e1d332fc 100644 --- a/execution/executor/src/tests/mock_vm/mod.rs +++ b/execution/executor/src/tests/mock_vm/mod.rs @@ -6,7 +6,7 @@ mod mock_vm_test; use anyhow::Result; -use aptos_crypto::{ed25519::Ed25519PrivateKey, PrivateKey, Uniform}; +use aptos_crypto::{ed25519::Ed25519PrivateKey, HashValue, PrivateKey, Uniform}; use aptos_types::{ account_address::AccountAddress, account_config::NEW_EPOCH_EVENT_V2_MOVE_TYPE_TAG, @@ -52,7 +52,6 @@ enum MockVMTransaction { pub static KEEP_STATUS: Lazy = Lazy::new(|| TransactionStatus::Keep(ExecutionStatus::Success)); -// We use 10 as the assertion error code for insufficient balance within the Aptos coin contract. pub static DISCARD_STATUS: Lazy = Lazy::new(|| TransactionStatus::Discard(StatusCode::INSUFFICIENT_BALANCE_FOR_TRANSACTION_FEE)); @@ -68,6 +67,8 @@ impl VMBlockExecutor for MockVM { transactions: &[SignatureVerifiedTransaction], state_view: &impl StateView, _onchain_config: BlockExecutorConfigFromOnchain, + _parent_block: Option<&HashValue>, + _current_block: Option, ) -> Result, VMStatus> { // output_cache is used to store the output of transactions so they are visible to later // transactions. diff --git a/execution/executor/src/tests/mod.rs b/execution/executor/src/tests/mod.rs index 8ca28af1a83ff..366c891ff1760 100644 --- a/execution/executor/src/tests/mod.rs +++ b/execution/executor/src/tests/mod.rs @@ -690,6 +690,7 @@ fn run_transactions_naive( .unwrap(), block_executor_onchain_config.clone(), None, + None, ) .unwrap(); let output = ApplyExecutionOutput::run(out, &ledger_view).unwrap(); diff --git a/execution/executor/src/workflow/do_get_execution_output.rs b/execution/executor/src/workflow/do_get_execution_output.rs index 4fad63d2e8261..5d2e962dff989 100644 --- a/execution/executor/src/workflow/do_get_execution_output.rs +++ b/execution/executor/src/workflow/do_get_execution_output.rs @@ -44,12 +44,14 @@ use std::{iter, sync::Arc}; pub struct DoGetExecutionOutput; impl DoGetExecutionOutput { + // Note: state checkpoint will be appended in when the current block is Some(..). pub fn by_transaction_execution( executor: &V, transactions: ExecutableTransactions, state_view: CachedStateView, onchain_config: BlockExecutorConfigFromOnchain, - append_state_checkpoint_to_block: Option, + parent_block: Option<&HashValue>, + current_block: Option, ) -> Result { let out = match transactions { ExecutableTransactions::Unsharded(txns) => { @@ -58,14 +60,15 @@ impl DoGetExecutionOutput { txns, state_view, onchain_config, - append_state_checkpoint_to_block, + parent_block, + current_block, )? }, ExecutableTransactions::Sharded(txns) => Self::by_transaction_execution_sharded::( txns, state_view, onchain_config, - append_state_checkpoint_to_block, + current_block, )?, }; @@ -89,10 +92,17 @@ impl DoGetExecutionOutput { transactions: Vec, state_view: CachedStateView, onchain_config: BlockExecutorConfigFromOnchain, - append_state_checkpoint_to_block: Option, + parent_block: Option<&HashValue>, + current_block: Option, ) -> Result { - let block_output = - Self::execute_block::(executor, &transactions, &state_view, onchain_config)?; + let block_output = Self::execute_block::( + executor, + &transactions, + &state_view, + onchain_config, + parent_block, + current_block, + )?; let (transaction_outputs, block_end_info) = block_output.into_inner(); Parser::parse( @@ -101,7 +111,7 @@ impl DoGetExecutionOutput { transaction_outputs, state_view.into_state_cache(), block_end_info, - append_state_checkpoint_to_block, + current_block, ) } @@ -202,9 +212,17 @@ impl DoGetExecutionOutput { transactions: &[SignatureVerifiedTransaction], state_view: &CachedStateView, onchain_config: BlockExecutorConfigFromOnchain, + parent_block: Option<&HashValue>, + current_block: Option, ) -> Result> { let _timer = OTHER_TIMERS.timer_with(&["vm_execute_block"]); - Ok(executor.execute_block(transactions, state_view, onchain_config)?) + Ok(executor.execute_block( + transactions, + state_view, + onchain_config, + parent_block, + current_block, + )?) } /// In consensus-only mode, executes the block of [Transaction]s using the @@ -217,6 +235,8 @@ impl DoGetExecutionOutput { transactions: &[SignatureVerifiedTransaction], state_view: &CachedStateView, onchain_config: BlockExecutorConfigFromOnchain, + parent_block: Option<&HashValue>, + current_block: Option, ) -> Result> { use aptos_types::{ state_store::{StateViewId, TStateView}, @@ -226,9 +246,13 @@ impl DoGetExecutionOutput { let transaction_outputs = match state_view.id() { // this state view ID implies a genesis block in non-test cases. - StateViewId::Miscellaneous => { - executor.execute_block(transactions, state_view, onchain_config)? - }, + StateViewId::Miscellaneous => executor.execute_block( + transactions, + state_view, + onchain_config, + parent_block, + current_block, + )?, _ => BlockOutput::new( transactions .iter() diff --git a/experimental/execution/ptx-executor/Cargo.toml b/experimental/execution/ptx-executor/Cargo.toml index 0da896d31500a..4ed757a8bba81 100644 --- a/experimental/execution/ptx-executor/Cargo.toml +++ b/experimental/execution/ptx-executor/Cargo.toml @@ -13,6 +13,7 @@ repository = { workspace = true } rust-version = { workspace = true } [dependencies] +aptos-crypto = { workspace = true } aptos-experimental-runtimes = { workspace = true } aptos-infallible = { workspace = true } aptos-logger = { workspace = true } diff --git a/experimental/execution/ptx-executor/src/lib.rs b/experimental/execution/ptx-executor/src/lib.rs index 9ed83b7d7a3f6..649c0651af63a 100644 --- a/experimental/execution/ptx-executor/src/lib.rs +++ b/experimental/execution/ptx-executor/src/lib.rs @@ -21,6 +21,7 @@ use crate::{ analyzer::PtxAnalyzer, finalizer::PtxFinalizer, metrics::TIMER, runner::PtxRunner, scheduler::PtxScheduler, sorter::PtxSorter, state_reader::PtxStateReader, }; +use aptos_crypto::HashValue; use aptos_experimental_runtimes::thread_manager::THREAD_MANAGER; use aptos_infallible::Mutex; use aptos_metrics_core::TimerHelper; @@ -53,6 +54,8 @@ impl VMBlockExecutor for PtxBlockExecutor { transactions: &[SignatureVerifiedTransaction], state_view: &(impl StateView + Sync), _onchain_config: BlockExecutorConfigFromOnchain, + _parent_block: Option<&HashValue>, + _current_block: Option, ) -> Result, VMStatus> { let _timer = TIMER.timer_with(&["block_total"]); diff --git a/testsuite/module-publish/src/main.rs b/testsuite/module-publish/src/main.rs index 7be0b3756122f..aac459c746366 100644 --- a/testsuite/module-publish/src/main.rs +++ b/testsuite/module-publish/src/main.rs @@ -150,7 +150,8 @@ fn write_package(file: &mut File, package_path: PathBuf, package_name: &str) -> // build package let package = BuiltPackage::build(package_path, BuildOptions::move_2()) .expect("building package must succeed"); - let code = package.extract_code(); + let modules = package.extract_code(); + let scripts = package.extract_script_code(); let package_metadata = package.extract_metadata().expect("Metadata must exist"); let metadata = bcs::to_bytes(&package_metadata).expect("Metadata must serialize"); @@ -164,7 +165,7 @@ fn write_package(file: &mut File, package_path: PathBuf, package_name: &str) -> let mut module_names = Vec::new(); // write out all modules - for module in &code { + for module in &modules { // this is an unfortunate way to find the module name but it is not // clear how to do it otherwise let compiled_module = CompiledModule::deserialize(module).expect("Module must deserialize"); @@ -180,6 +181,14 @@ fn write_package(file: &mut File, package_path: PathBuf, package_name: &str) -> module_names.push(name); } + // write out scripts (allow a single script for now) + assert!(scripts.len() <= 1); + for script in &scripts { + let name: String = format!("SCRIPT_{}", package_name.to_uppercase(),); + writeln!(file).expect("Empty line failed"); + write_lazy(file, name.as_str(), script); + } + writeln!(file).expect("Empty line failed"); writeln!(file, "#[rustfmt::skip]").expect("rustfmt skip failed"); writeln!( diff --git a/testsuite/module-publish/src/packages/module_loading_chain_dependencies/Move.toml b/testsuite/module-publish/src/packages/module_loading_chain_dependencies/Move.toml new file mode 100644 index 0000000000000..5a4a2c24bf0e5 --- /dev/null +++ b/testsuite/module-publish/src/packages/module_loading_chain_dependencies/Move.toml @@ -0,0 +1,9 @@ +[package] +name = 'module_loading_chain_dependencies' +version = '1.0.0' + +[dependencies] +AptosStdlib = { local = "../../../../../aptos-move/framework/aptos-stdlib" } + +[addresses] +publisher_address = "0xABCD" diff --git a/testsuite/module-publish/src/packages/module_loading_chain_dependencies/sources/chain_dependencies.move b/testsuite/module-publish/src/packages/module_loading_chain_dependencies/sources/chain_dependencies.move new file mode 100644 index 0000000000000..d19aaa59cf0e3 --- /dev/null +++ b/testsuite/module-publish/src/packages/module_loading_chain_dependencies/sources/chain_dependencies.move @@ -0,0 +1,1526 @@ +module publisher_address::chain_dependencies { + + public entry fun run() { + let sum = publisher_address::chain_dependencies_1::next(); + assert!(sum == 20, 77); + } +} + +module publisher_address::chain_dependencies_1 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_2::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_2 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_3::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_3 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_4::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_4 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_5::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_5 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_6::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_6 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_7::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_7 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_8::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_8 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_9::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_9 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_10::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_10 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_11::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_11 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_12::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_12 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_13::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_13 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_14::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_14 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_15::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_15 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_16::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_16 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_17::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_17 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_18::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_18 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_19::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_19 { + + public fun next(): u64 { + 1 + publisher_address::chain_dependencies_20::next() + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_dependencies_20 { + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} diff --git a/testsuite/module-publish/src/packages/module_loading_chain_friends/Move.toml b/testsuite/module-publish/src/packages/module_loading_chain_friends/Move.toml new file mode 100644 index 0000000000000..fe6f6ab77c285 --- /dev/null +++ b/testsuite/module-publish/src/packages/module_loading_chain_friends/Move.toml @@ -0,0 +1,9 @@ +[package] +name = 'module_loading_chain_friends' +version = '1.0.0' + +[dependencies] +AptosStdlib = { local = "../../../../../aptos-move/framework/aptos-stdlib" } + +[addresses] +publisher_address = "0xABCD" diff --git a/testsuite/module-publish/src/packages/module_loading_chain_friends/sources/chain_friends.move b/testsuite/module-publish/src/packages/module_loading_chain_friends/sources/chain_friends.move new file mode 100644 index 0000000000000..1623e10fe5b4c --- /dev/null +++ b/testsuite/module-publish/src/packages/module_loading_chain_friends/sources/chain_friends.move @@ -0,0 +1,1469 @@ +module publisher_address::chain_friends { + friend publisher_address::chain_friends_1; + + public entry fun run() { + // no-op + } +} + +module publisher_address::chain_friends_1 { + friend publisher_address::chain_friends_2; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_2 { + friend publisher_address::chain_friends_3; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_3 { + friend publisher_address::chain_friends_4; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_4 { + friend publisher_address::chain_friends_5; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_5 { + friend publisher_address::chain_friends_6; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_6 { + friend publisher_address::chain_friends_7; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_7 { + friend publisher_address::chain_friends_8; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_8 { + friend publisher_address::chain_friends_9; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_9 { + friend publisher_address::chain_friends_10; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_10 { + friend publisher_address::chain_friends_11; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_11 { + friend publisher_address::chain_friends_12; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_12 { + friend publisher_address::chain_friends_13; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_13 { + friend publisher_address::chain_friends_14; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_14 { + friend publisher_address::chain_friends_15; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_15 { + friend publisher_address::chain_friends_16; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_16 { + friend publisher_address::chain_friends_17; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_17 { + friend publisher_address::chain_friends_18; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_18 { + friend publisher_address::chain_friends_19; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_19 { + friend publisher_address::chain_friends_20; + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::chain_friends_20 { + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} diff --git a/testsuite/module-publish/src/packages/module_loading_star_dependencies/Move.toml b/testsuite/module-publish/src/packages/module_loading_star_dependencies/Move.toml new file mode 100644 index 0000000000000..b4861ac4a5507 --- /dev/null +++ b/testsuite/module-publish/src/packages/module_loading_star_dependencies/Move.toml @@ -0,0 +1,9 @@ +[package] +name = 'module_loading_star_dependencies' +version = '1.0.0' + +[dependencies] +AptosStdlib = { local = "../../../../../aptos-move/framework/aptos-stdlib" } + +[addresses] +publisher_address = "0xABCD" diff --git a/testsuite/module-publish/src/packages/module_loading_star_dependencies/sources/star_dependencies.move b/testsuite/module-publish/src/packages/module_loading_star_dependencies/sources/star_dependencies.move new file mode 100644 index 0000000000000..d5eba39b43544 --- /dev/null +++ b/testsuite/module-publish/src/packages/module_loading_star_dependencies/sources/star_dependencies.move @@ -0,0 +1,1609 @@ +module publisher_address::star_dependencies { + use publisher_address::star_dependencies_1; + use publisher_address::star_dependencies_2; + use publisher_address::star_dependencies_3; + use publisher_address::star_dependencies_4; + use publisher_address::star_dependencies_5; + use publisher_address::star_dependencies_6; + use publisher_address::star_dependencies_7; + use publisher_address::star_dependencies_8; + use publisher_address::star_dependencies_9; + use publisher_address::star_dependencies_10; + use publisher_address::star_dependencies_11; + use publisher_address::star_dependencies_12; + use publisher_address::star_dependencies_13; + use publisher_address::star_dependencies_14; + use publisher_address::star_dependencies_15; + use publisher_address::star_dependencies_16; + use publisher_address::star_dependencies_17; + use publisher_address::star_dependencies_18; + use publisher_address::star_dependencies_19; + use publisher_address::star_dependencies_20; + + public entry fun run() { + let sum = 0; + + sum = sum + star_dependencies_1::next(); + sum = sum + star_dependencies_2::next(); + sum = sum + star_dependencies_3::next(); + sum = sum + star_dependencies_4::next(); + sum = sum + star_dependencies_5::next(); + sum = sum + star_dependencies_6::next(); + sum = sum + star_dependencies_7::next(); + sum = sum + star_dependencies_8::next(); + sum = sum + star_dependencies_9::next(); + sum = sum + star_dependencies_10::next(); + sum = sum + star_dependencies_11::next(); + sum = sum + star_dependencies_12::next(); + sum = sum + star_dependencies_13::next(); + sum = sum + star_dependencies_14::next(); + sum = sum + star_dependencies_15::next(); + sum = sum + star_dependencies_16::next(); + sum = sum + star_dependencies_17::next(); + sum = sum + star_dependencies_18::next(); + sum = sum + star_dependencies_19::next(); + sum = sum + star_dependencies_20::next(); + + assert!(sum == 20, 77); + } +} + +module publisher_address::star_dependencies_1 { + + const MAGIC: u64 = 1; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_2 { + + const MAGIC: u64 = 2; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_3 { + + const MAGIC: u64 = 3; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_4 { + + const MAGIC: u64 = 4; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_5 { + + const MAGIC: u64 = 5; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_6 { + + const MAGIC: u64 = 6; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_7 { + + const MAGIC: u64 = 7; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_8 { + + const MAGIC: u64 = 8; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_9 { + + const MAGIC: u64 = 9; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_10 { + + const MAGIC: u64 = 10; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_11 { + + const MAGIC: u64 = 11; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_12 { + + const MAGIC: u64 = 12; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_13 { + + const MAGIC: u64 = 13; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_14 { + + const MAGIC: u64 = 14; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_15 { + + const MAGIC: u64 = 15; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_16 { + + const MAGIC: u64 = 16; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_17 { + + const MAGIC: u64 = 17; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_18 { + + const MAGIC: u64 = 18; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_19 { + + const MAGIC: u64 = 19; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} + +module publisher_address::star_dependencies_20 { + + const MAGIC: u64 = 20; + + public fun next(): u64 { + 1 + } + + // Functions bellow are used to make module verification a bit more expensive. + + struct Data has copy, drop, store { + data: vector, + } + + struct Resource has key { + id: u64, + name: aptos_std::string::String, + data: Data, + } + + struct Counter has key { + count: u64, + } + + public fun copy_pasta_ref( + r1: &Resource, + r2: &Resource, + c1: &Counter, + c2: &Counter, + ): &u64 { + let ret1 = &r1.id; + let ret2 = &r2.id; + if (*ret1 < *ret2) { + ret1 = ret2; + ret2 = &c1.count; + } else { + ret1 = &r2.id; + ret2 = &c2.count; + }; + if (*ret2 < r2.id) { + ret1 = ret2; + ret2 = &c2.count; + } else if (ret1 != &r1.id) { + ret1 = &c1.count; + ret2 = &r2.id; + }; + if (*ret1 < *ret2) { + ret2 = ret1; + ret1 + } else { + ret1 = ret2; + ret2 + }; + if (ret1 == ret2) { + ret1 + } else { + ret2 + } + } + + public fun loop_bcs(count: u64, len: u64) { + let vec = std::vector::empty(); + let i = 0; + while (i < len) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + } + } +} diff --git a/testsuite/module-publish/src/packages/simple/scripts/main.move b/testsuite/module-publish/src/packages/simple/scripts/main.move index 0c6c4767afb65..b41d1fc0de31e 100644 --- a/testsuite/module-publish/src/packages/simple/scripts/main.move +++ b/testsuite/module-publish/src/packages/simple/scripts/main.move @@ -2,16 +2,53 @@ script { // Note: this constant can be replaced in compiled script to make it hash to a different value. const SENDER: address = @0x1; - fun main(sender: &signer) { + fun main(_sender: &signer) { // The idea is to to ensure that this script takes some time to be deserialized and verified, but the actual // execution time is small (no-op). - if (false) { - 0xABCD::simple::loop_nop(sender, 0); - 0xABCD::simple::loop_arithmetic(sender, 0); - 0xABCD::simple::loop_bcs(sender, 0, 0); - if (false) { - while (true) {} + let count = 23; + while (count > 0) { + count = count - 1; + }; + + let a; + let b = 0; + let c; + let d = 0; + while (count > 0) { + count = count - 1; + + a = b + 1; + c = d + 1; + b = a + 1; + d = b - a; + b = c + 1; + a = b - c; + b = a + 1; + + // can never be true + if (a > b && b > c && c > d && d > a) { + count = count + 1; } + }; + + let count = 5; + let vec = std::vector::empty(); + let i = 0; + while (i < 20) { + std::vector::push_back(&mut vec, i); + i = i + 1; + }; + + let sum: u64 = 0; + + while (count > 0) { + let val = std::bcs::to_bytes(&vec); + sum = sum + ((*std::vector::borrow(&val, 0)) as u64); + count = count - 1; + }; + + if (count == 1000000) { + while (true) {} } } } diff --git a/third_party/move/move-vm/runtime/src/config.rs b/third_party/move/move-vm/runtime/src/config.rs index 5eebeba504cbe..81584ce0f8178 100644 --- a/third_party/move/move-vm/runtime/src/config.rs +++ b/third_party/move/move-vm/runtime/src/config.rs @@ -44,7 +44,7 @@ impl Default for VMConfig { ty_builder: TypeBuilder::with_limits(128, 20), disallow_dispatch_for_native: true, use_compatibility_checker_v2: true, - use_loader_v2: false, + use_loader_v2: std::env::var("USE_LOADER_V2").is_ok(), } } } diff --git a/third_party/move/move-vm/runtime/src/storage/environment.rs b/third_party/move/move-vm/runtime/src/storage/environment.rs index 62d885c36a96a..bc152dd1cc06b 100644 --- a/third_party/move/move-vm/runtime/src/storage/environment.rs +++ b/third_party/move/move-vm/runtime/src/storage/environment.rs @@ -25,7 +25,10 @@ use move_core_types::{ identifier::{IdentStr, Identifier}, vm_status::{sub_status::unknown_invariant_violation::EPARANOID_FAILURE, StatusCode}, }; -use move_vm_types::sha3_256; +use move_vm_types::{ + loaded_data::runtime_types::{StructIdentifier, StructNameIndex}, + sha3_256, +}; use std::sync::Arc; /// [MoveVM] runtime environment encapsulating different configurations. Shared between the VM and @@ -284,6 +287,15 @@ impl RuntimeEnvironment { self.flush_struct_info_cache(); self.struct_name_index_map.flush(); } + + /// Test-only function to be able to populate [StructNameIndexMap] outside of this crate. + #[cfg(any(test, feature = "testing"))] + pub fn struct_name_to_idx_for_test( + &self, + struct_name: StructIdentifier, + ) -> PartialVMResult { + self.struct_name_index_map.struct_name_to_idx(struct_name) + } } impl Clone for RuntimeEnvironment { diff --git a/third_party/move/move-vm/runtime/src/storage/implementations/unsync_code_storage.rs b/third_party/move/move-vm/runtime/src/storage/implementations/unsync_code_storage.rs index 51539b35ffcd0..19f6f1ae55fee 100644 --- a/third_party/move/move-vm/runtime/src/storage/implementations/unsync_code_storage.rs +++ b/third_party/move/move-vm/runtime/src/storage/implementations/unsync_code_storage.rs @@ -29,11 +29,16 @@ use std::sync::Arc; pub struct UnsyncCodeStorage(UnsyncCodeStorageImpl); impl UnsyncCodeStorage { - /// Returns the underlying module storage used by this code storage. + /// Returns the reference to the underlying module storage used by this code storage. pub fn module_storage(&self) -> &M { &self.0.module_storage } + /// Returns the underlying module storage used by this code storage. + pub fn into_module_storage(self) -> M { + self.0.module_storage + } + /// Test-only method that checks the state of the script cache. #[cfg(test)] pub(crate) fn assert_cached_state<'b>( diff --git a/third_party/move/move-vm/runtime/src/storage/implementations/unsync_module_storage.rs b/third_party/move/move-vm/runtime/src/storage/implementations/unsync_module_storage.rs index c423c410b0ea3..186b0b86f875f 100644 --- a/third_party/move/move-vm/runtime/src/storage/implementations/unsync_module_storage.rs +++ b/third_party/move/move-vm/runtime/src/storage/implementations/unsync_module_storage.rs @@ -71,7 +71,7 @@ impl WithHash for BytesWithHash { } /// Placeholder for module versioning since we do not allow to mutate [UnsyncModuleStorage]. -#[derive(Clone, Eq, PartialEq, Ord, PartialOrd)] +#[derive(Clone, Default, Eq, PartialEq, Ord, PartialOrd)] struct NoVersion; /// Private implementation of module storage based on non-[Sync] module cache and the baseline @@ -125,14 +125,11 @@ impl<'s, S: ModuleBytesStorage, E: WithRuntimeEnvironment> ModuleCodeBuilder type Extension = BytesWithHash; type Key = ModuleId; type Verified = Module; - type Version = NoVersion; fn build( &self, key: &Self::Key, - ) -> VMResult< - Option>, - > { + ) -> VMResult>> { let bytes = match self .base_storage .fetch_module_bytes(key.address(), key.name())? @@ -144,7 +141,7 @@ impl<'s, S: ModuleBytesStorage, E: WithRuntimeEnvironment> ModuleCodeBuilder .runtime_environment() .deserialize_into_compiled_module(&bytes)?; let extension = Arc::new(BytesWithHash::new(bytes, hash)); - let module = ModuleCode::from_deserialized(compiled_module, extension, NoVersion); + let module = ModuleCode::from_deserialized(compiled_module, extension); Ok(Some(module)) } } @@ -167,6 +164,27 @@ impl<'s, S: ModuleBytesStorage, E: WithRuntimeEnvironment> UnsyncModuleStorage<' &self.0.base_storage } + /// Returns an iterator of all modules that have been cached and verified. + pub fn unpack_into_verified_modules_iter( + self, + ) -> ( + BorrowedOrOwned<'s, S>, + impl Iterator)>, + ) { + let verified_modules_iter = + self.0 + .module_cache + .into_modules_iter() + .flat_map(|(key, module)| { + module.code().is_verified().then(|| { + // TODO(loader_v2): + // We should be able to take ownership here, instead of clones. + (key, module.code().verified().clone()) + }) + }); + (self.0.base_storage, verified_modules_iter) + } + /// Test-only method that checks the state of the module cache. #[cfg(test)] pub(crate) fn assert_cached_state<'b>( @@ -174,15 +192,17 @@ impl<'s, S: ModuleBytesStorage, E: WithRuntimeEnvironment> UnsyncModuleStorage<' deserialized: Vec<&'b ModuleId>, verified: Vec<&'b ModuleId>, ) { + use claims::*; + assert_eq!(self.0.num_modules(), deserialized.len() + verified.len()); for id in deserialized { let result = self.0.get_module_or_build_with(id, &self.0); - let module = claims::assert_some!(claims::assert_ok!(result)); + let module = assert_some!(assert_ok!(result)).0; assert!(!module.code().is_verified()) } for id in verified { let result = self.0.get_module_or_build_with(id, &self.0); - let module = claims::assert_some!(claims::assert_ok!(result)); + let module = assert_some!(assert_ok!(result)).0; assert!(module.code().is_verified()) } } diff --git a/third_party/move/move-vm/runtime/src/storage/module_storage.rs b/third_party/move/move-vm/runtime/src/storage/module_storage.rs index 041c4eb92f775..714871a70cc77 100644 --- a/third_party/move/move-vm/runtime/src/storage/module_storage.rs +++ b/third_party/move/move-vm/runtime/src/storage/module_storage.rs @@ -11,7 +11,7 @@ use move_core_types::{ metadata::Metadata, }; use move_vm_types::{ - code::{ModuleCache, ModuleCode, ModuleCodeBuilder, WithBytes, WithHash}, + code::{ModuleCache, ModuleCode, ModuleCodeBuilder, WithBytes, WithHash, WithSize}, module_cyclic_dependency_error, module_linker_error, }; use std::sync::Arc; @@ -116,10 +116,9 @@ where Deserialized = CompiledModule, Verified = Module, Extension = E, - Version = V, >, - E: WithBytes + WithHash, - V: Clone + Ord, + E: WithBytes + WithSize + WithHash, + V: Clone + Default + Ord, { fn check_module_exists( &self, @@ -138,7 +137,7 @@ where let id = ModuleId::new(*address, module_name.to_owned()); Ok(self .get_module_or_build_with(&id, self)? - .map(|module| module.extension().bytes().clone())) + .map(|(module, _)| module.extension().bytes().clone())) } fn fetch_module_size_in_bytes( @@ -149,7 +148,7 @@ where let id = ModuleId::new(*address, module_name.to_owned()); Ok(self .get_module_or_build_with(&id, self)? - .map(|module| module.extension().bytes().len())) + .map(|(module, _)| module.extension().bytes().len())) } fn fetch_module_metadata( @@ -160,7 +159,7 @@ where let id = ModuleId::new(*address, module_name.to_owned()); Ok(self .get_module_or_build_with(&id, self)? - .map(|module| module.code().deserialized().metadata.clone())) + .map(|(module, _)| module.code().deserialized().metadata.clone())) } fn fetch_deserialized_module( @@ -171,7 +170,7 @@ where let id = ModuleId::new(*address, module_name.to_owned()); Ok(self .get_module_or_build_with(&id, self)? - .map(|module| module.code().deserialized().clone())) + .map(|(module, _)| module.code().deserialized().clone())) } fn fetch_verified_module( @@ -183,8 +182,8 @@ where // Look up the verified module in cache, if it is not there, or if the module is not yet // verified, we need to load & verify its transitive dependencies. - let module = match self.get_module_or_build_with(&id, self)? { - Some(module) => module, + let (module, version) = match self.get_module_or_build_with(&id, self)? { + Some(module_and_version) => module_and_version, None => return Ok(None), }; @@ -197,6 +196,7 @@ where Ok(Some(visit_dependencies_and_verify( id, module, + version, &mut visited, self, )?)) @@ -218,7 +218,8 @@ where /// is clearly infeasible. fn visit_dependencies_and_verify( module_id: ModuleId, - module: Arc>, + module: Arc>, + version: V, visited: &mut HashSet, module_cache_with_context: &T, ) -> VMResult> @@ -235,10 +236,9 @@ where Deserialized = CompiledModule, Verified = Module, Extension = E, - Version = V, >, - E: WithBytes + WithHash, - V: Clone + Ord, + E: WithBytes + WithSize + WithHash, + V: Clone + Default + Ord, { let runtime_environment = module_cache_with_context.runtime_environment(); @@ -260,7 +260,7 @@ where for (addr, name) in locally_verified_code.immediate_dependencies_iter() { let dependency_id = ModuleId::new(*addr, name.to_owned()); - let dependency = module_cache_with_context + let (dependency, dependency_version) = module_cache_with_context .get_module_or_build_with(&dependency_id, module_cache_with_context)? .ok_or_else(|| module_linker_error!(addr, name))?; @@ -275,6 +275,7 @@ where let verified_dependency = visit_dependencies_and_verify( dependency_id.clone(), dependency, + dependency_version, visited, module_cache_with_context, )?; @@ -294,7 +295,7 @@ where module_id, verified_code, module.extension().clone(), - module.version(), + version, )?; Ok(module.code().verified().clone()) } diff --git a/third_party/move/move-vm/types/src/code/cache/module_cache.rs b/third_party/move/move-vm/types/src/code/cache/module_cache.rs index 5d9bf1772c633..7697c20e3a8c6 100644 --- a/third_party/move/move-vm/types/src/code/cache/module_cache.rs +++ b/third_party/move/move-vm/types/src/code/cache/module_cache.rs @@ -10,35 +10,36 @@ use move_binary_format::errors::VMResult; use std::{cell::RefCell, cmp::Ordering, hash::Hash, mem, ops::Deref, sync::Arc}; /// Represents module code stored in [ModuleCode]. -pub struct ModuleCode { +pub struct ModuleCode { /// Module's code, either deserialized or verified. code: Code, - /// Module's extension - any additional metadata associated with this module. + /// Module's extension - any additional metadata associated with this module. It can be module + /// bytes, its size, etc. We use an arc here to avoid expensive clones. extension: Arc, - /// Version of the code (e.g., which transaction within the block published this module). - version: V, } -impl ModuleCode +impl ModuleCode where VC: Deref>, - V: Clone + Ord, { /// Creates new [ModuleCode] from deserialized code. - pub fn from_deserialized(deserialized_code: DC, extension: Arc, version: V) -> Self { + pub fn from_deserialized(deserialized_code: DC, extension: Arc) -> Self { Self { code: Code::from_deserialized(deserialized_code), extension, - version, } } /// Creates new [ModuleCode] from verified code. - pub fn from_verified(verified_code: VC, extension: Arc, version: V) -> Self { + pub fn from_verified(verified_code: VC, extension: Arc) -> Self { + Self::from_arced_verified(Arc::new(verified_code), extension) + } + + /// Creates new [ModuleCode] from [Arc]ed verified code. + pub fn from_arced_verified(verified_code: Arc, extension: Arc) -> Self { Self { - code: Code::from_verified(verified_code), + code: Code::from_arced_verified(verified_code), extension, - version, } } @@ -51,27 +52,13 @@ where pub fn extension(&self) -> &Arc { &self.extension } - - /// Returns module's version. - pub fn version(&self) -> V { - self.version.clone() - } - - /// Sets the module version. - pub fn set_version(&mut self, version: V) { - self.version = version; - } } -impl Clone for ModuleCode -where - V: Clone, -{ +impl Clone for ModuleCode { fn clone(&self) -> Self { Self { code: self.code.clone(), extension: self.extension.clone(), - version: self.version.clone(), } } } @@ -82,16 +69,13 @@ pub trait ModuleCodeBuilder { type Deserialized; type Verified; type Extension; - type Version: Clone + Ord; /// For the given key, returns [ModuleCode] if it exists, and [None] otherwise. In case /// initialization fails, returns an error. fn build( &self, key: &Self::Key, - ) -> VMResult< - Option>, - >; + ) -> VMResult>>; } /// Interface used by any module cache implementation. @@ -101,7 +85,7 @@ pub trait ModuleCache { type Deserialized; type Verified; type Extension; - type Version: Clone + Ord; + type Version: Clone + Default + Ord; /// Stores deserialized code at specified version to the module cache if there was no entry /// associated with this key before. If module cache already contains an entry, then: @@ -129,12 +113,11 @@ pub trait ModuleCache { verified_code: Self::Verified, extension: Arc, version: Self::Version, - ) -> VMResult>>; + ) -> VMResult>>; /// Ensures that the entry in the module cache is initialized using the provided initializer, /// if it was not stored before. Returns the stored module, or [None] if it does not exist. If - /// initialization fails, returns the error. The caller can also provide the kind of read they - /// intend to do. + /// initialization fails, returns the error. fn get_module_or_build_with( &self, key: &Self::Key, @@ -143,16 +126,74 @@ pub trait ModuleCache { Deserialized = Self::Deserialized, Verified = Self::Verified, Extension = Self::Extension, - Version = Self::Version, >, ) -> VMResult< - Option>>, + Option<( + Arc>, + Self::Version, + )>, >; /// Returns the number of modules in cache. fn num_modules(&self) -> usize; } +/// Same as [ModuleCode], additionally storing a version. +struct VersionedModuleCode { + module_code: Arc>, + version: V, +} + +impl VersionedModuleCode +where + V: Default + Clone + Ord, +{ + /// Returns new [ModuleCode] with the specified version. + fn new(module_code: ModuleCode, version: V) -> Self { + Self { + module_code: Arc::new(module_code), + version, + } + } + + /// Returns new [ModuleCode] with the default (storage) version. + fn new_with_default_version(module_code: ModuleCode) -> Self { + Self::new(module_code, V::default()) + } + + /// Returns the reference to the stored module. + fn module_code(&self) -> &Arc> { + &self.module_code + } + + /// Returns the stored module. + fn into_module_code(self) -> Arc> { + self.module_code + } + + /// Returns the version associated with this module. + fn version(&self) -> V { + self.version.clone() + } + + /// Returns the clone of the module along with its version. + fn as_module_code_and_version(&self) -> (Arc>, V) { + (self.module_code.clone(), self.version.clone()) + } +} + +impl Clone for VersionedModuleCode +where + V: Default + Clone + Ord, +{ + fn clone(&self) -> Self { + Self { + module_code: self.module_code.clone(), + version: self.version.clone(), + } + } +} + /// An error when inserting a module with a smaller version to module cache containing the higher /// version. macro_rules! version_too_small_error { @@ -167,14 +208,14 @@ macro_rules! version_too_small_error { /// Non-[Sync] version of module cache suitable for sequential execution. pub struct UnsyncModuleCache { - module_cache: RefCell>>>, + module_cache: RefCell>>, } impl UnsyncModuleCache where K: Eq + Hash + Clone, VC: Deref>, - V: Clone + Ord, + V: Clone + Default + Ord, { /// Returns an empty module cache. pub fn empty() -> Self { @@ -184,8 +225,11 @@ where } /// Returns the iterator to all keys and modules stored in the cache. - pub fn into_modules_iter(self) -> impl Iterator>)> { - self.module_cache.into_inner().into_iter() + pub fn into_modules_iter(self) -> impl Iterator>)> { + self.module_cache + .into_inner() + .into_iter() + .map(|(k, m)| (k, m.into_module_code())) } } @@ -193,7 +237,7 @@ impl ModuleCache for UnsyncModuleCache where K: Eq + Hash + Clone, VC: Deref>, - V: Clone + Ord, + V: Clone + Default + Ord, { type Deserialized = DC; type Extension = E; @@ -215,18 +259,14 @@ where Ordering::Less => Err(version_too_small_error!()), Ordering::Equal => Ok(()), Ordering::Greater => { - let module = Arc::new(ModuleCode::from_deserialized( - deserialized_code, - extension, - version, - )); - entry.insert(module); + let module = ModuleCode::from_deserialized(deserialized_code, extension); + entry.insert(VersionedModuleCode::new(module, version)); Ok(()) }, }, Vacant(entry) => { - let module = ModuleCode::from_deserialized(deserialized_code, extension, version); - entry.insert(Arc::new(module)); + let module = ModuleCode::from_deserialized(deserialized_code, extension); + entry.insert(VersionedModuleCode::new(module, version)); Ok(()) }, } @@ -238,34 +278,42 @@ where verified_code: Self::Verified, extension: Arc, version: Self::Version, - ) -> VMResult>> - { + ) -> VMResult>> { use hashbrown::hash_map::Entry::*; match self.module_cache.borrow_mut().entry(key) { Occupied(mut entry) => match version.cmp(&entry.get().version()) { Ordering::Less => Err(version_too_small_error!()), Ordering::Equal => { - if entry.get().code().is_verified() { - Ok(entry.get().clone()) + if entry.get().module_code().code().is_verified() { + Ok(entry.get().module_code().clone()) } else { - let module = - Arc::new(ModuleCode::from_verified(verified_code, extension, version)); - entry.insert(module.clone()); + let versioned_module = VersionedModuleCode::new( + ModuleCode::from_verified(verified_code, extension), + version, + ); + let module = versioned_module.module_code().clone(); + entry.insert(versioned_module); Ok(module) } }, Ordering::Greater => { - let module = - Arc::new(ModuleCode::from_verified(verified_code, extension, version)); - entry.insert(module.clone()); + let versioned_module = VersionedModuleCode::new( + ModuleCode::from_verified(verified_code, extension), + version, + ); + let module = versioned_module.module_code().clone(); + entry.insert(versioned_module); Ok(module) }, }, - Vacant(entry) => { - let module = ModuleCode::from_verified(verified_code, extension, version); - Ok(entry.insert(Arc::new(module)).clone()) - }, + Vacant(entry) => Ok(entry + .insert(VersionedModuleCode::new( + ModuleCode::from_verified(verified_code, extension), + version, + )) + .module_code() + .clone()), } } @@ -277,18 +325,22 @@ where Deserialized = Self::Deserialized, Verified = Self::Verified, Extension = Self::Extension, - Version = Self::Version, >, ) -> VMResult< - Option>>, + Option<( + Arc>, + Self::Version, + )>, > { use hashbrown::hash_map::Entry::*; Ok(match self.module_cache.borrow_mut().entry(key.clone()) { - Occupied(entry) => Some(entry.get().clone()), - Vacant(entry) => builder - .build(key)? - .map(|module| entry.insert(Arc::new(module)).clone()), + Occupied(entry) => Some(entry.get().as_module_code_and_version()), + Vacant(entry) => builder.build(key)?.map(|module| { + entry + .insert(VersionedModuleCode::new_with_default_version(module)) + .as_module_code_and_version() + }), }) } @@ -299,14 +351,14 @@ where /// [Sync] version of module cache, suitable for parallel execution. pub struct SyncModuleCache { - module_cache: DashMap>>>, + module_cache: DashMap>>, } impl SyncModuleCache where K: Eq + Hash + Clone, VC: Deref>, - V: Clone + Ord, + V: Clone + Default + Ord, { /// Returns a new empty module cache. pub fn empty() -> Self { @@ -322,12 +374,10 @@ where } /// Takes the modules stored in the module cache, and returns an iterator of keys and modules. - pub fn take_modules_iter( - &mut self, - ) -> impl Iterator>)> { + pub fn take_modules_iter(&mut self) -> impl Iterator>)> { mem::take(&mut self.module_cache) .into_iter() - .map(|(key, module)| (key, module.into_inner())) + .map(|(key, module)| (key, module.into_inner().into_module_code())) } } @@ -335,7 +385,7 @@ impl ModuleCache for SyncModuleCache where K: Eq + Hash + Clone, VC: Deref>, - V: Clone + Ord, + V: Clone + Default + Ord, { type Deserialized = DC; type Extension = E; @@ -357,18 +407,14 @@ where Ordering::Less => Err(version_too_small_error!()), Ordering::Equal => Ok(()), Ordering::Greater => { - let module = Arc::new(ModuleCode::from_deserialized( - deserialized_code, - extension, - version, - )); - entry.insert(CachePadded::new(module)); + let module = ModuleCode::from_deserialized(deserialized_code, extension); + entry.insert(CachePadded::new(VersionedModuleCode::new(module, version))); Ok(()) }, }, Vacant(entry) => { - let module = ModuleCode::from_deserialized(deserialized_code, extension, version); - entry.insert(CachePadded::new(Arc::new(module))); + let module = ModuleCode::from_deserialized(deserialized_code, extension); + entry.insert(CachePadded::new(VersionedModuleCode::new(module, version))); Ok(()) }, } @@ -380,37 +426,39 @@ where verified_code: Self::Verified, extension: Arc, version: Self::Version, - ) -> VMResult>> - { + ) -> VMResult>> { use dashmap::mapref::entry::Entry::*; match self.module_cache.entry(key) { Occupied(mut entry) => match version.cmp(&entry.get().version()) { Ordering::Less => Err(version_too_small_error!()), Ordering::Equal => { - if entry.get().code().is_verified() { - Ok(entry.get().deref().clone()) + if entry.get().module_code().code().is_verified() { + Ok(entry.get().module_code().clone()) } else { - let module = - Arc::new(ModuleCode::from_verified(verified_code, extension, version)); - entry.insert(CachePadded::new(module.clone())); + let versioned_module = VersionedModuleCode::new( + ModuleCode::from_verified(verified_code, extension), + version, + ); + let module = versioned_module.module_code().clone(); + entry.insert(CachePadded::new(versioned_module)); Ok(module) } }, Ordering::Greater => { - let module = - Arc::new(ModuleCode::from_verified(verified_code, extension, version)); - entry.insert(CachePadded::new(module.clone())); + let versioned_module = VersionedModuleCode::new( + ModuleCode::from_verified(verified_code, extension), + version, + ); + let module = versioned_module.module_code().clone(); + entry.insert(CachePadded::new(versioned_module)); Ok(module) }, }, Vacant(entry) => { - let module = ModuleCode::from_verified(verified_code, extension, version); - Ok(entry - .insert(CachePadded::new(Arc::new(module))) - .deref() - .deref() - .clone()) + let module = ModuleCode::from_verified(verified_code, extension); + let v = entry.insert(CachePadded::new(VersionedModuleCode::new(module, version))); + Ok(v.module_code().clone()) }, } } @@ -423,27 +471,28 @@ where Deserialized = Self::Deserialized, Verified = Self::Verified, Extension = Self::Extension, - Version = Self::Version, >, ) -> VMResult< - Option>>, + Option<( + Arc>, + Self::Version, + )>, > { use dashmap::mapref::entry::Entry::*; - if let Some(module) = self.module_cache.get(key) { - return Ok(Some(Arc::clone(module.deref()))); + if let Some(v) = self.module_cache.get(key).as_deref() { + return Ok(Some(v.as_module_code_and_version())); } Ok(match self.module_cache.entry(key.clone()) { - Occupied(entry) => Some(Arc::clone(entry.get())), - Vacant(entry) => match builder.build(key)? { - Some(module) => { - let module = Arc::new(module); - entry.insert(CachePadded::new(module.clone())); - Some(module) - }, - None => None, - }, + Occupied(entry) => Some(entry.get().as_module_code_and_version()), + Vacant(entry) => builder.build(key)?.map(|module| { + entry + .insert(CachePadded::new( + VersionedModuleCode::new_with_default_version(module), + )) + .as_module_code_and_version() + }), }) } @@ -455,7 +504,7 @@ where #[cfg(test)] mod test { use super::*; - use crate::code::{MockDeserializedCode, MockVerifiedCode}; + use crate::code::{mock_extension, MockDeserializedCode, MockExtension, MockVerifiedCode}; use claims::{assert_ok, assert_some}; use move_binary_format::errors::{Location, PartialVMError}; use move_core_types::vm_status::StatusCode; @@ -464,17 +513,15 @@ mod test { impl ModuleCodeBuilder for Unreachable { type Deserialized = MockDeserializedCode; - type Extension = (); + type Extension = MockExtension; type Key = usize; type Verified = MockVerifiedCode; - type Version = u32; fn build( &self, _key: &Self::Key, - ) -> VMResult< - Option>, - > { + ) -> VMResult>> + { unreachable!("Should never be called!") } } @@ -483,19 +530,17 @@ mod test { impl ModuleCodeBuilder for WithSomeValue { type Deserialized = MockDeserializedCode; - type Extension = (); + type Extension = MockExtension; type Key = usize; type Verified = MockVerifiedCode; - type Version = u32; fn build( &self, _key: &Self::Key, - ) -> VMResult< - Option>, - > { + ) -> VMResult>> + { let code = MockDeserializedCode::new(self.0); - Ok(Some(ModuleCode::from_deserialized(code, Arc::new(()), 0))) + Ok(Some(ModuleCode::from_deserialized(code, mock_extension(8)))) } } @@ -503,17 +548,15 @@ mod test { impl ModuleCodeBuilder for WithNone { type Deserialized = MockDeserializedCode; - type Extension = (); + type Extension = MockExtension; type Key = usize; type Verified = MockVerifiedCode; - type Version = u32; fn build( &self, _key: &Self::Key, - ) -> VMResult< - Option>, - > { + ) -> VMResult>> + { Ok(None) } } @@ -522,17 +565,15 @@ mod test { impl ModuleCodeBuilder for WithError { type Deserialized = MockDeserializedCode; - type Extension = (); + type Extension = MockExtension; type Key = usize; type Verified = MockVerifiedCode; - type Version = u32; fn build( &self, _key: &Self::Key, - ) -> VMResult< - Option>, - > { + ) -> VMResult>> + { Err(PartialVMError::new(StatusCode::STORAGE_ERROR).finish(Location::Undefined)) } } @@ -542,7 +583,7 @@ mod test { Key = usize, Deserialized = MockDeserializedCode, Verified = MockVerifiedCode, - Extension = (), + Extension = MockExtension, Version = u32, >, ) { @@ -550,57 +591,61 @@ mod test { assert_ok!(module_cache.insert_deserialized_module( 1, MockDeserializedCode::new(1), - Arc::new(()), - 0, + mock_extension(8), + 0 )); assert_ok!(module_cache.insert_deserialized_module( 2, MockDeserializedCode::new(2), - Arc::new(()), - 0, + mock_extension(8), + 0 )); assert_eq!(module_cache.num_modules(), 2); let deserialized_module_1 = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&1, &Unreachable) - )); + )) + .0; assert_eq!(deserialized_module_1.code().deserialized().value(), 1); let deserialized_module_2 = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&2, &Unreachable) - )); + )) + .0; assert_eq!(deserialized_module_2.code().deserialized().value(), 2); // Module cache already stores deserialized code at the same version. assert_ok!(module_cache.insert_deserialized_module( 1, MockDeserializedCode::new(10), - Arc::new(()), + mock_extension(8), 0 )); assert_eq!(module_cache.num_modules(), 2); let deserialized_module = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&1, &Unreachable) - )); + )) + .0; assert_eq!(deserialized_module.code().deserialized().value(), 1); // Module cache stores deserialized code at lower version, so it should be replaced. assert_ok!(module_cache.insert_deserialized_module( 1, MockDeserializedCode::new(100), - Arc::new(()), + mock_extension(8), 10 )); assert_eq!(module_cache.num_modules(), 2); let deserialized_module = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&1, &Unreachable) - )); + )) + .0; assert_eq!(deserialized_module.code().deserialized().value(), 100); // We already have higher-versioned deserialized code stored. let result = module_cache.insert_deserialized_module( 1, MockDeserializedCode::new(100), - Arc::new(()), + mock_extension(8), 5, ); assert!(result.is_err()); @@ -609,7 +654,7 @@ mod test { assert_ok!(module_cache.insert_verified_module( 3, MockVerifiedCode::new(3), - Arc::new(()), + mock_extension(8), 10 )); assert_eq!(module_cache.num_modules(), 3); @@ -618,7 +663,7 @@ mod test { let result = module_cache.insert_deserialized_module( 3, MockDeserializedCode::new(30), - Arc::new(()), + mock_extension(8), 0, ); assert!(result.is_err()); @@ -627,38 +672,43 @@ mod test { assert_ok!(module_cache.insert_deserialized_module( 3, MockDeserializedCode::new(300), - Arc::new(()), + mock_extension(8), 10 )); assert_eq!(module_cache.num_modules(), 3); let deserialized_module = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&3, &Unreachable) - )); + )) + .0; assert_eq!(deserialized_module.code().deserialized().value(), 3); // If the version is higher, we replace the module even though it was verified before. assert_ok!(module_cache.insert_deserialized_module( 3, MockDeserializedCode::new(3000), - Arc::new(()), + mock_extension(8), 20 )); assert_eq!(module_cache.num_modules(), 3); let deserialized_module = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&3, &Unreachable) - )); + )) + .0; assert_eq!(deserialized_module.code().deserialized().value(), 3000); // Check states. let module_1 = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&1, &Unreachable) - )); + )) + .0; let module_2 = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&2, &Unreachable) - )); + )) + .0; let module_3 = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&3, &Unreachable) - )); + )) + .0; assert!(matches!(module_1.code(), Code::Deserialized(s) if s.value() == 100)); assert!(matches!(module_2.code(), Code::Deserialized(s) if s.value() == 2)); assert!(matches!(module_3.code(), Code::Deserialized(s) if s.value() == 3000)); @@ -669,7 +719,7 @@ mod test { Key = usize, Deserialized = MockDeserializedCode, Verified = MockVerifiedCode, - Extension = (), + Extension = MockExtension, Version = u32, >, ) { @@ -677,14 +727,14 @@ mod test { let verified_module_1 = assert_ok!(module_cache.insert_verified_module( 1, MockVerifiedCode::new(1), - Arc::new(()), + mock_extension(8), 10, )); let verified_module_2 = assert_ok!(module_cache.insert_verified_module( 2, MockVerifiedCode::new(2), - Arc::new(()), - 10, + mock_extension(8), + 10 )); assert_eq!(module_cache.num_modules(), 2); @@ -697,18 +747,19 @@ mod test { assert_ok!(module_cache.insert_deserialized_module( 2, MockDeserializedCode::new(20), - Arc::new(()), + mock_extension(8), 10 )); assert_eq!(module_cache.num_modules(), 2); let deserialized_module = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&2, &Unreachable) - )); + )) + .0; assert_eq!(deserialized_module.code().deserialized().value(), 2); let verified_module = assert_ok!(module_cache.insert_verified_module( 2, MockVerifiedCode::new(200), - Arc::new(()), + mock_extension(8), 10 )); assert_eq!(module_cache.num_modules(), 2); @@ -718,32 +769,37 @@ mod test { let result = module_cache.insert_deserialized_module( 1, MockDeserializedCode::new(10), - Arc::new(()), + mock_extension(8), 0, ); assert!(result.is_err()); - let result = - module_cache.insert_verified_module(1, MockVerifiedCode::new(100), Arc::new(()), 0); + let result = module_cache.insert_verified_module( + 1, + MockVerifiedCode::new(100), + mock_extension(8), + 0, + ); assert!(result.is_err()); // Higher versions should be inserted, whether they are verified or deserialized. assert_ok!(module_cache.insert_deserialized_module( 1, MockDeserializedCode::new(1000), - Arc::new(()), + mock_extension(8), 100 )); assert_eq!(module_cache.num_modules(), 2); let deserialized_module = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&1, &Unreachable) - )); + )) + .0; assert!(!deserialized_module.code().is_verified()); assert_eq!(deserialized_module.code().deserialized().value(), 1000); let verified_module = assert_ok!(module_cache.insert_verified_module( 1, MockVerifiedCode::new(10_000), - Arc::new(()), + mock_extension(8), 1000 )); assert_eq!(module_cache.num_modules(), 2); @@ -753,10 +809,12 @@ mod test { // Check states. let module_1 = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&1, &Unreachable) - )); + )) + .0; let module_2 = assert_some!(assert_ok!( module_cache.get_module_or_build_with(&2, &Unreachable) - )); + )) + .0; assert!(matches!(module_1.code(), Code::Verified(s) if s.value() == 10_000)); assert!(matches!(module_2.code(), Code::Verified(s) if s.value() == 2)); } @@ -766,32 +824,32 @@ mod test { Key = usize, Deserialized = MockDeserializedCode, Verified = MockVerifiedCode, - Extension = (), + Extension = MockExtension, Version = u32, >, ) { assert_ok!(module_cache.insert_deserialized_module( 1, MockDeserializedCode::new(1), - Arc::new(()), - 0, + mock_extension(8), + 0 )); assert_ok!(module_cache.insert_verified_module( 2, MockVerifiedCode::new(2), - Arc::new(()), - 0, + mock_extension(8), + 0 )); // Get existing deserialized module. let result = module_cache.get_module_or_build_with(&1, &WithSomeValue(100)); - let module_1 = assert_some!(assert_ok!(result)); + let module_1 = assert_some!(assert_ok!(result)).0; assert!(!module_1.code().is_verified()); assert_eq!(module_1.code().deserialized().value(), 1); // Get existing verified module. let result = module_cache.get_module_or_build_with(&2, &WithError); - let module_2 = assert_some!(assert_ok!(result)); + let module_2 = assert_some!(assert_ok!(result)).0; assert!(module_2.code().is_verified()); assert_eq!(module_2.code().deserialized().value(), 2); @@ -808,13 +866,13 @@ mod test { // Successful initialization. let result = module_cache.get_module_or_build_with(&3, &WithSomeValue(300)); - let module_3 = assert_some!(assert_ok!(result)); + let module_3 = assert_some!(assert_ok!(result)).0; assert!(!module_3.code().is_verified()); assert_eq!(module_3.code().deserialized().value(), 300); assert_eq!(module_cache.num_modules(), 3); let result = module_cache.get_module_or_build_with(&3, &WithSomeValue(1000)); - let module_3 = assert_some!(assert_ok!(result)); + let module_3 = assert_some!(assert_ok!(result)).0; assert!(!module_3.code().is_verified()); assert_eq!(module_3.code().deserialized().value(), 300); assert_eq!(module_cache.num_modules(), 3); diff --git a/third_party/move/move-vm/types/src/code/cache/test_types.rs b/third_party/move/move-vm/types/src/code/cache/test_types.rs index 2b79b5d607045..1ad64e4bb1590 100644 --- a/third_party/move/move-vm/types/src/code/cache/test_types.rs +++ b/third_party/move/move-vm/types/src/code/cache/test_types.rs @@ -1,10 +1,10 @@ // Copyright (c) The Move Contributors // SPDX-License-Identifier: Apache-2.0 -use crate::code::ModuleCode; +use crate::code::{ModuleCode, WithSize}; use std::{ops::Deref, sync::Arc}; -#[derive(Clone)] +#[derive(Clone, Debug)] pub struct MockDeserializedCode(usize); impl MockDeserializedCode { @@ -17,6 +17,7 @@ impl MockDeserializedCode { } } +#[derive(Debug)] pub struct MockVerifiedCode(Arc); impl MockVerifiedCode { @@ -33,24 +34,43 @@ impl Deref for MockVerifiedCode { } } -pub fn mock_deserialized_code( +pub fn mock_deserialized_code( value: usize, - version: V, -) -> Arc> { + extension: E, +) -> Arc> { Arc::new(ModuleCode::from_deserialized( MockDeserializedCode::new(value), - Arc::new(()), - version, + Arc::new(extension), )) } -pub fn mock_verified_code( +pub fn mock_verified_code( value: usize, - version: V, -) -> Arc> { + extension: E, +) -> Arc> { Arc::new(ModuleCode::from_verified( MockVerifiedCode::new(value), - Arc::new(()), - version, + Arc::new(extension), )) } + +#[derive(Clone, Debug)] +pub struct MockExtension { + mock_size: usize, +} + +impl MockExtension { + pub fn new(mock_size: usize) -> Self { + Self { mock_size } + } +} + +impl WithSize for MockExtension { + fn size_in_bytes(&self) -> usize { + self.mock_size + } +} + +pub fn mock_extension(mock_size: usize) -> Arc { + Arc::new(MockExtension::new(mock_size)) +} diff --git a/third_party/move/move-vm/types/src/code/cache/types.rs b/third_party/move/move-vm/types/src/code/cache/types.rs index b9cb0154b65a4..12cd078c89d43 100644 --- a/third_party/move/move-vm/types/src/code/cache/types.rs +++ b/third_party/move/move-vm/types/src/code/cache/types.rs @@ -9,7 +9,13 @@ use std::{ops::Deref, sync::Arc}; pub trait WithBytes { fn bytes(&self) -> &Bytes; +} + +pub trait WithSize { + fn size_in_bytes(&self) -> usize; +} +impl WithSize for T { fn size_in_bytes(&self) -> usize { self.bytes().len() } @@ -61,6 +67,11 @@ where Self::Verified(Arc::new(verified_code)) } + /// Returns new verified code from [Arc]ed instance. + pub fn from_arced_verified(verified_code: Arc) -> Self { + Self::Verified(verified_code) + } + /// Returns true if the code is verified. pub fn is_verified(&self) -> bool { match self { diff --git a/third_party/move/move-vm/types/src/code/mod.rs b/third_party/move/move-vm/types/src/code/mod.rs index 399519dca919b..eadb57123c3bf 100644 --- a/third_party/move/move-vm/types/src/code/mod.rs +++ b/third_party/move/move-vm/types/src/code/mod.rs @@ -7,7 +7,8 @@ mod storage; #[cfg(any(test, feature = "testing"))] pub use cache::test_types::{ - mock_deserialized_code, mock_verified_code, MockDeserializedCode, MockVerifiedCode, + mock_deserialized_code, mock_extension, mock_verified_code, MockDeserializedCode, + MockExtension, MockVerifiedCode, }; pub use cache::{ module_cache::{ @@ -15,6 +16,6 @@ pub use cache::{ UnsyncModuleCache, }, script_cache::{ambassador_impl_ScriptCache, ScriptCache, SyncScriptCache, UnsyncScriptCache}, - types::{Code, WithAddress, WithBytes, WithHash, WithName}, + types::{Code, WithAddress, WithBytes, WithHash, WithName, WithSize}, }; pub use storage::ModuleBytesStorage; diff --git a/types/src/block_executor/config.rs b/types/src/block_executor/config.rs index 586b76e8c7942..0ce382d3d94a5 100644 --- a/types/src/block_executor/config.rs +++ b/types/src/block_executor/config.rs @@ -4,6 +4,32 @@ use crate::on_chain_config::BlockGasLimitType; use serde::{Deserialize, Serialize}; +/// Local, per-node configurations for module cache. While caches can be persisted across multiple +/// block executions, these configurations allow to specify cache sizes, etc. +#[derive(Clone, Debug)] +pub struct BlockExecutorModuleCacheLocalConfig { + /// If true, when global caches are empty, Aptos framework is prefetched into module cache. + pub prefetch_framework_code: bool, + /// The maximum size of module cache (the sum of serialized sizes of all cached modules in + /// bytes). + pub max_module_cache_size_in_bytes: usize, + /// The maximum size (in terms of entries) of struct name re-indexing map stored in the runtime + /// environment. + pub max_struct_name_index_map_num_entries: usize, +} + +impl Default for BlockExecutorModuleCacheLocalConfig { + fn default() -> Self { + Self { + prefetch_framework_code: true, + // Use 1Gb for now, should be large enough to cache all mainnet modules (at the time + // of writing this comment, 13.11.24). + max_module_cache_size_in_bytes: 1024 * 1024 * 1024, + max_struct_name_index_map_num_entries: 1_000_000, + } + } +} + /// Local, per-node configuration. #[derive(Clone, Debug)] pub struct BlockExecutorLocalConfig { @@ -14,6 +40,22 @@ pub struct BlockExecutorLocalConfig { // If true, we will discard the failed blocks and continue with the next block. // (allow_fallback needs to be set) pub discard_failed_blocks: bool, + pub module_cache_config: BlockExecutorModuleCacheLocalConfig, +} + +impl BlockExecutorLocalConfig { + /// Returns a new config with specified concurrency level and: + /// - Allowed fallback to sequential execution from parallel. + /// - Not allowed discards of failed blocks. + /// - Default module cache configs. + pub fn default_with_concurrency_level(concurrency_level: usize) -> Self { + Self { + concurrency_level, + allow_fallback: true, + discard_failed_blocks: false, + module_cache_config: BlockExecutorModuleCacheLocalConfig::default(), + } + } } /// Configuration from on-chain configuration, that is @@ -40,7 +82,7 @@ impl BlockExecutorConfigFromOnchain { pub const fn on_but_large_for_test() -> Self { Self { block_gas_limit_type: - // present, so code is excercised, but large to not limit blocks + // present, so code is exercised, but large to not limit blocks BlockGasLimitType::ComplexLimitV1 { effective_block_gas_limit: 1_000_000_000, execution_gas_effective_multiplier: 1, @@ -69,11 +111,7 @@ pub struct BlockExecutorConfig { impl BlockExecutorConfig { pub fn new_no_block_limit(concurrency_level: usize) -> Self { Self { - local: BlockExecutorLocalConfig { - concurrency_level, - allow_fallback: true, - discard_failed_blocks: false, - }, + local: BlockExecutorLocalConfig::default_with_concurrency_level(concurrency_level), onchain: BlockExecutorConfigFromOnchain::new_no_block_limit(), } } @@ -83,11 +121,7 @@ impl BlockExecutorConfig { maybe_block_gas_limit: Option, ) -> Self { Self { - local: BlockExecutorLocalConfig { - concurrency_level, - allow_fallback: true, - discard_failed_blocks: false, - }, + local: BlockExecutorLocalConfig::default_with_concurrency_level(concurrency_level), onchain: BlockExecutorConfigFromOnchain::new_maybe_block_limit(maybe_block_gas_limit), } } diff --git a/types/src/on_chain_config/aptos_features.rs b/types/src/on_chain_config/aptos_features.rs index d1297014ad21f..ff069bab6559d 100644 --- a/types/src/on_chain_config/aptos_features.rs +++ b/types/src/on_chain_config/aptos_features.rs @@ -196,6 +196,11 @@ impl Default for Features { for feature in FeatureFlag::default_features() { features.enable(feature); } + if std::env::var("USE_LOADER_V2").is_ok() { + features.enable(FeatureFlag::ENABLE_LOADER_V2); + } else { + features.disable(FeatureFlag::ENABLE_LOADER_V2); + } features } } diff --git a/types/src/state_store/mod.rs b/types/src/state_store/mod.rs index 3b16a4f75d6fe..49450ffd7a4df 100644 --- a/types/src/state_store/mod.rs +++ b/types/src/state_store/mod.rs @@ -14,6 +14,8 @@ use aptos_experimental_runtimes::thread_manager::THREAD_MANAGER; use arr_macro::arr; use bytes::Bytes; use move_core_types::move_resource::MoveResource; +#[cfg(any(test, feature = "testing"))] +use std::hash::Hash; use std::{collections::HashMap, ops::Deref}; pub mod errors; @@ -25,9 +27,8 @@ pub mod table; pub type Result = std::result::Result; -/// `StateView` is a trait that defines a read-only snapshot of the global state. It is passed to -/// the VM for transaction execution, during which the VM is guaranteed to read anything at the -/// given state. +/// A trait that defines a read-only snapshot of the global state. It is passed to the VM for +/// transaction execution, during which the VM is guaranteed to read anything at the given state. pub trait TStateView { type Key; @@ -96,6 +97,38 @@ where } } +/// Test-only basic [StateView] implementation with generic keys. +#[cfg(any(test, feature = "testing"))] +pub struct MockStateView { + data: HashMap, +} + +#[cfg(any(test, feature = "testing"))] +impl MockStateView { + pub fn empty() -> Self { + Self { + data: HashMap::new(), + } + } + + pub fn new(data: HashMap) -> Self { + Self { data } + } +} + +#[cfg(any(test, feature = "testing"))] +impl TStateView for MockStateView { + type Key = K; + + fn get_state_value(&self, state_key: &Self::Key) -> Result, StateviewError> { + Ok(self.data.get(state_key).cloned()) + } + + fn get_usage(&self) -> std::result::Result { + unimplemented!("Irrelevant for tests"); + } +} + pub type ShardedStateUpdates = [HashMap>; 16]; pub fn create_empty_sharded_state_updates() -> ShardedStateUpdates {