From 5d80999366c0a896e906fd286e64b48c48d6ee16 Mon Sep 17 00:00:00 2001 From: Tarek Mohamed Abdalla Date: Thu, 2 Mar 2023 15:38:15 +0200 Subject: [PATCH 01/13] make 1 sec BABE --- Cargo.lock | 160 +++++++++++++++++++-------------------- node/Cargo.toml | 10 +-- node/src/benchmarking.rs | 2 +- node/src/chain_spec.rs | 2 +- node/src/command.rs | 4 +- node/src/rpc.rs | 2 +- node/src/service.rs | 6 +- runtime/Cargo.toml | 2 +- runtime/src/lib.rs | 2 +- 9 files changed, 95 insertions(+), 95 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 3aeeee7..930c8e1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3982,86 +3982,6 @@ dependencies = [ "memoffset 0.6.5", ] -[[package]] -name = "node-template" -version = "4.0.0-dev" -dependencies = [ - "clap", - "frame-benchmarking", - "frame-benchmarking-cli", - "frame-system", - "futures", - "jsonrpsee", - "node-template-runtime", - "pallet-transaction-payment", - "pallet-transaction-payment-rpc", - "sc-basic-authorship", - "sc-cli", - "sc-client-api", - "sc-consensus", - "sc-consensus-aura", - "sc-executor", - "sc-finality-grandpa", - "sc-keystore", - "sc-rpc", - "sc-rpc-api", - "sc-service", - "sc-telemetry", - "sc-transaction-pool", - "sc-transaction-pool-api", - "sp-api", - "sp-block-builder", - "sp-blockchain", - "sp-consensus", - "sp-consensus-aura", - "sp-core", - "sp-finality-grandpa", - "sp-inherents", - "sp-io", - "sp-keyring", - "sp-runtime", - "sp-timestamp", - "substrate-build-script-utils", - "substrate-frame-rpc-system", - "try-runtime-cli", -] - -[[package]] -name = "node-template-runtime" -version = "4.0.0-dev" -dependencies = [ - "frame-benchmarking", - "frame-executive", - "frame-support", - "frame-system", - "frame-system-benchmarking", - "frame-system-rpc-runtime-api", - "frame-try-runtime", - "pallet-aura", - "pallet-balances", - "pallet-grandpa", - "pallet-randomness-collective-flip", - "pallet-sudo", - "pallet-template", - "pallet-timestamp", - "pallet-transaction-payment", - "pallet-transaction-payment-rpc-runtime-api", - "parity-scale-codec", - "scale-info", - "sp-api", - "sp-block-builder", - "sp-consensus-aura", - "sp-core", - "sp-inherents", - "sp-offchain", - "sp-runtime", - "sp-session", - "sp-std", - "sp-transaction-pool", - "sp-version", - "substrate-wasm-builder", -] - [[package]] name = "nohash-hasher" version = "0.2.0" @@ -9349,6 +9269,86 @@ dependencies = [ "time 0.3.17", ] +[[package]] +name = "xsocial-node" +version = "4.0.0-dev" +dependencies = [ + "clap", + "frame-benchmarking", + "frame-benchmarking-cli", + "frame-system", + "futures", + "jsonrpsee", + "pallet-transaction-payment", + "pallet-transaction-payment-rpc", + "sc-basic-authorship", + "sc-cli", + "sc-client-api", + "sc-consensus", + "sc-consensus-aura", + "sc-executor", + "sc-finality-grandpa", + "sc-keystore", + "sc-rpc", + "sc-rpc-api", + "sc-service", + "sc-telemetry", + "sc-transaction-pool", + "sc-transaction-pool-api", + "sp-api", + "sp-block-builder", + "sp-blockchain", + "sp-consensus", + "sp-consensus-aura", + "sp-core", + "sp-finality-grandpa", + "sp-inherents", + "sp-io", + "sp-keyring", + "sp-runtime", + "sp-timestamp", + "substrate-build-script-utils", + "substrate-frame-rpc-system", + "try-runtime-cli", + "xsocial-runtime", +] + +[[package]] +name = "xsocial-runtime" +version = "4.0.0-dev" +dependencies = [ + "frame-benchmarking", + "frame-executive", + "frame-support", + "frame-system", + "frame-system-benchmarking", + "frame-system-rpc-runtime-api", + "frame-try-runtime", + "pallet-aura", + "pallet-balances", + "pallet-grandpa", + "pallet-randomness-collective-flip", + "pallet-sudo", + "pallet-template", + "pallet-timestamp", + "pallet-transaction-payment", + "pallet-transaction-payment-rpc-runtime-api", + "parity-scale-codec", + "scale-info", + "sp-api", + "sp-block-builder", + "sp-consensus-aura", + "sp-core", + "sp-inherents", + "sp-offchain", + "sp-runtime", + "sp-session", + "sp-std", + "sp-transaction-pool", + "sp-version", + "substrate-wasm-builder", +] + [[package]] name = "yamux" version = "0.10.2" diff --git a/node/Cargo.toml b/node/Cargo.toml index c10f7b4..869da1a 100644 --- a/node/Cargo.toml +++ b/node/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "node-template" +name = "xsocial-node" version = "4.0.0-dev" description = "A fresh FRAME-based Substrate node, ready for hacking." authors = ["Substrate DevHub "] @@ -14,7 +14,7 @@ build = "build.rs" targets = ["x86_64-unknown-linux-gnu"] [[bin]] -name = "node-template" +name = "xsocial-node" [dependencies] clap = { version = "4.0.9", features = ["derive"] } @@ -59,7 +59,7 @@ frame-benchmarking = { version = "4.0.0-dev", git = "https://github.com/parityte frame-benchmarking-cli = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } # Local Dependencies -node-template-runtime = { version = "4.0.0-dev", path = "../runtime" } +xsocial-runtime = { version = "4.0.0-dev", path = "../runtime" } # CLI-specific dependencies try-runtime-cli = { version = "0.10.0-dev", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } @@ -71,10 +71,10 @@ substrate-build-script-utils = { version = "3.0.0", git = "https://github.com/pa default = [] # Dependencies that are only required if runtime benchmarking should be build. runtime-benchmarks = [ - "node-template-runtime/runtime-benchmarks", + "xsocial-runtime/runtime-benchmarks", "frame-benchmarking/runtime-benchmarks", "frame-benchmarking-cli/runtime-benchmarks", ] # Enable features that allow the runtime to be tried and debugged. Name might be subject to change # in the near future. -try-runtime = ["node-template-runtime/try-runtime", "try-runtime-cli/try-runtime"] +try-runtime = ["xsocial-runtime/try-runtime", "try-runtime-cli/try-runtime"] diff --git a/node/src/benchmarking.rs b/node/src/benchmarking.rs index 37e0e46..15bf9d3 100644 --- a/node/src/benchmarking.rs +++ b/node/src/benchmarking.rs @@ -4,7 +4,7 @@ use crate::service::FullClient; -use node_template_runtime as runtime; +use xsocial_runtime as runtime; use runtime::{AccountId, Balance, BalancesCall, SystemCall}; use sc_cli::Result; use sc_client_api::BlockBackend; diff --git a/node/src/chain_spec.rs b/node/src/chain_spec.rs index ef34ec3..20141cb 100644 --- a/node/src/chain_spec.rs +++ b/node/src/chain_spec.rs @@ -1,4 +1,4 @@ -use node_template_runtime::{ +use xsocial_runtime::{ AccountId, AuraConfig, BalancesConfig, GenesisConfig, GrandpaConfig, Signature, SudoConfig, SystemConfig, WASM_BINARY, }; diff --git a/node/src/command.rs b/node/src/command.rs index 15cd69b..5416000 100644 --- a/node/src/command.rs +++ b/node/src/command.rs @@ -5,7 +5,7 @@ use crate::{ service, }; use frame_benchmarking_cli::{BenchmarkCmd, ExtrinsicFactory, SUBSTRATE_REFERENCE_HARDWARE}; -use node_template_runtime::{Block, EXISTENTIAL_DEPOSIT}; +use xsocial_runtime::{Block, EXISTENTIAL_DEPOSIT}; use sc_cli::{ChainSpec, RuntimeVersion, SubstrateCli}; use sc_service::PartialComponents; use sp_keyring::Sr25519Keyring; @@ -45,7 +45,7 @@ impl SubstrateCli for Cli { } fn native_runtime_version(_: &Box) -> &'static RuntimeVersion { - &node_template_runtime::VERSION + &xsocial_runtime::VERSION } } diff --git a/node/src/rpc.rs b/node/src/rpc.rs index 981f375..c0ebe6d 100644 --- a/node/src/rpc.rs +++ b/node/src/rpc.rs @@ -8,7 +8,7 @@ use std::sync::Arc; use jsonrpsee::RpcModule; -use node_template_runtime::{opaque::Block, AccountId, Balance, Index}; +use xsocial_runtime::{opaque::Block, AccountId, Balance, Index}; use sc_transaction_pool_api::TransactionPool; use sp_api::ProvideRuntimeApi; use sp_block_builder::BlockBuilder; diff --git a/node/src/service.rs b/node/src/service.rs index ee84646..258d396 100644 --- a/node/src/service.rs +++ b/node/src/service.rs @@ -1,6 +1,6 @@ //! Service and ServiceFactory implementation. Specialized wrapper over substrate service. -use node_template_runtime::{self, opaque::Block, RuntimeApi}; +use xsocial_runtime::{self, opaque::Block, RuntimeApi}; use sc_client_api::BlockBackend; use sc_consensus_aura::{ImportQueueParams, SlotProportion, StartAuraParams}; pub use sc_executor::NativeElseWasmExecutor; @@ -23,11 +23,11 @@ impl sc_executor::NativeExecutionDispatch for ExecutorDispatch { type ExtendHostFunctions = (); fn dispatch(method: &str, data: &[u8]) -> Option> { - node_template_runtime::api::dispatch(method, data) + xsocial_runtime::api::dispatch(method, data) } fn native_version() -> sc_executor::NativeVersion { - node_template_runtime::native_version() + xsocial_runtime::native_version() } } diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 7b42889..ee7161e 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "node-template-runtime" +name = "xsocial-runtime" version = "4.0.0-dev" description = "A fresh FRAME-based Substrate node, ready for hacking." authors = ["Substrate DevHub "] diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index f4372af..5722f9b 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -118,7 +118,7 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { /// up by `pallet_aura` to implement `fn slot_duration()`. /// /// Change this to adjust the block time. -pub const MILLISECS_PER_BLOCK: u64 = 6000; +pub const MILLISECS_PER_BLOCK: u64 = 1000; // NOTE: Currently it is not possible to change the slot duration after the chain has started. // Attempting to do so will brick block production. From 501b368ee3b0190e4602b7e294302b6b913c2d96 Mon Sep 17 00:00:00 2001 From: Tarek Mohamed Abdalla Date: Thu, 2 Mar 2023 16:11:38 +0200 Subject: [PATCH 02/13] add social pallets --- Cargo.lock | 103 +++ Cargo.toml | 2 +- node/src/chain_spec.rs | 5 +- pallets/permissions/Cargo.toml | 39 ++ .../permissions/src/default_permissions.rs | 61 ++ pallets/permissions/src/lib.rs | 91 +++ pallets/permissions/src/types.rs | 143 ++++ pallets/posts/Cargo.toml | 50 ++ pallets/posts/rpc/Cargo.toml | 43 ++ pallets/posts/rpc/runtime-api/Cargo.toml | 35 + pallets/posts/rpc/runtime-api/src/lib.rs | 39 ++ pallets/posts/rpc/src/lib.rs | 270 ++++++++ pallets/posts/src/benchmarking.rs | 147 +++++ pallets/posts/src/functions.rs | 337 ++++++++++ pallets/posts/src/lib.rs | 485 ++++++++++++++ pallets/posts/src/rpc.rs | 313 +++++++++ pallets/posts/src/types.rs | 71 ++ pallets/posts/src/weights.rs | 169 +++++ pallets/posts/tests/Cargo.toml | 60 ++ pallets/posts/tests/src/comments_tests.rs | 209 ++++++ pallets/posts/tests/src/lib.rs | 10 + pallets/posts/tests/src/mock.rs | 151 +++++ pallets/posts/tests/src/post_tests.rs | 612 ++++++++++++++++++ pallets/posts/tests/src/shared_posts_tests.rs | 180 ++++++ pallets/posts/tests/src/tests_utils.rs | 488 ++++++++++++++ pallets/roles/Cargo.toml | 57 ++ pallets/roles/rpc/Cargo.toml | 51 ++ pallets/roles/rpc/runtime-api/Cargo.toml | 43 ++ pallets/roles/rpc/runtime-api/src/lib.rs | 18 + pallets/roles/rpc/src/lib.rs | 96 +++ pallets/roles/src/benchmarking.rs | 146 +++++ pallets/roles/src/functions.rs | 187 ++++++ pallets/roles/src/lib.rs | 490 ++++++++++++++ pallets/roles/src/mock.rs | 345 ++++++++++ pallets/roles/src/rpc.rs | 47 ++ pallets/roles/src/tests.rs | 567 ++++++++++++++++ pallets/roles/src/types.rs | 43 ++ pallets/roles/src/weights.rs | 188 ++++++ pallets/space-follows/Cargo.toml | 40 ++ pallets/space-follows/rpc/Cargo.toml | 49 ++ .../space-follows/rpc/runtime-api/Cargo.toml | 41 ++ .../space-follows/rpc/runtime-api/src/lib.rs | 16 + pallets/space-follows/rpc/src/lib.rs | 76 +++ pallets/space-follows/src/benchmarking.rs | 52 ++ pallets/space-follows/src/lib.rs | 170 +++++ pallets/space-follows/src/rpc.rs | 17 + pallets/space-follows/src/weights.rs | 95 +++ pallets/space-follows/tests/Cargo.toml | 58 ++ pallets/space-follows/tests/src/lib.rs | 6 + pallets/space-follows/tests/src/mock.rs | 122 ++++ pallets/space-follows/tests/src/tests.rs | 65 ++ .../space-follows/tests/src/tests_utils.rs | 134 ++++ pallets/spaces/Cargo.toml | 48 ++ pallets/spaces/rpc/Cargo.toml | 51 ++ pallets/spaces/rpc/runtime-api/Cargo.toml | 43 ++ pallets/spaces/rpc/runtime-api/src/lib.rs | 32 + pallets/spaces/rpc/src/lib.rs | 195 ++++++ pallets/spaces/src/benchmarking.rs | 57 ++ pallets/spaces/src/lib.rs | 434 +++++++++++++ pallets/spaces/src/rpc.rs | 142 ++++ pallets/spaces/src/types.rs | 83 +++ pallets/spaces/src/weights.rs | 91 +++ pallets/spaces/tests/Cargo.toml | 58 ++ pallets/spaces/tests/src/lib.rs | 6 + pallets/spaces/tests/src/mock.rs | 144 +++++ pallets/spaces/tests/src/tests.rs | 345 ++++++++++ pallets/spaces/tests/src/tests_utils.rs | 396 ++++++++++++ pallets/support/Cargo.toml | 35 + pallets/support/src/lib.rs | 256 ++++++++ pallets/support/src/traits.rs | 7 + pallets/support/src/traits/common.rs | 27 + pallets/support/src/traits/moderation.rs | 51 ++ runtime/Cargo.toml | 128 ++-- runtime/src/lib.rs | 55 ++ 74 files changed, 9958 insertions(+), 58 deletions(-) create mode 100644 pallets/permissions/Cargo.toml create mode 100644 pallets/permissions/src/default_permissions.rs create mode 100644 pallets/permissions/src/lib.rs create mode 100644 pallets/permissions/src/types.rs create mode 100644 pallets/posts/Cargo.toml create mode 100644 pallets/posts/rpc/Cargo.toml create mode 100644 pallets/posts/rpc/runtime-api/Cargo.toml create mode 100644 pallets/posts/rpc/runtime-api/src/lib.rs create mode 100644 pallets/posts/rpc/src/lib.rs create mode 100644 pallets/posts/src/benchmarking.rs create mode 100644 pallets/posts/src/functions.rs create mode 100644 pallets/posts/src/lib.rs create mode 100644 pallets/posts/src/rpc.rs create mode 100644 pallets/posts/src/types.rs create mode 100644 pallets/posts/src/weights.rs create mode 100644 pallets/posts/tests/Cargo.toml create mode 100644 pallets/posts/tests/src/comments_tests.rs create mode 100644 pallets/posts/tests/src/lib.rs create mode 100644 pallets/posts/tests/src/mock.rs create mode 100644 pallets/posts/tests/src/post_tests.rs create mode 100644 pallets/posts/tests/src/shared_posts_tests.rs create mode 100644 pallets/posts/tests/src/tests_utils.rs create mode 100644 pallets/roles/Cargo.toml create mode 100644 pallets/roles/rpc/Cargo.toml create mode 100644 pallets/roles/rpc/runtime-api/Cargo.toml create mode 100644 pallets/roles/rpc/runtime-api/src/lib.rs create mode 100644 pallets/roles/rpc/src/lib.rs create mode 100644 pallets/roles/src/benchmarking.rs create mode 100644 pallets/roles/src/functions.rs create mode 100644 pallets/roles/src/lib.rs create mode 100644 pallets/roles/src/mock.rs create mode 100644 pallets/roles/src/rpc.rs create mode 100644 pallets/roles/src/tests.rs create mode 100644 pallets/roles/src/types.rs create mode 100644 pallets/roles/src/weights.rs create mode 100644 pallets/space-follows/Cargo.toml create mode 100644 pallets/space-follows/rpc/Cargo.toml create mode 100644 pallets/space-follows/rpc/runtime-api/Cargo.toml create mode 100644 pallets/space-follows/rpc/runtime-api/src/lib.rs create mode 100644 pallets/space-follows/rpc/src/lib.rs create mode 100644 pallets/space-follows/src/benchmarking.rs create mode 100644 pallets/space-follows/src/lib.rs create mode 100644 pallets/space-follows/src/rpc.rs create mode 100644 pallets/space-follows/src/weights.rs create mode 100644 pallets/space-follows/tests/Cargo.toml create mode 100644 pallets/space-follows/tests/src/lib.rs create mode 100644 pallets/space-follows/tests/src/mock.rs create mode 100644 pallets/space-follows/tests/src/tests.rs create mode 100644 pallets/space-follows/tests/src/tests_utils.rs create mode 100644 pallets/spaces/Cargo.toml create mode 100644 pallets/spaces/rpc/Cargo.toml create mode 100644 pallets/spaces/rpc/runtime-api/Cargo.toml create mode 100644 pallets/spaces/rpc/runtime-api/src/lib.rs create mode 100644 pallets/spaces/rpc/src/lib.rs create mode 100644 pallets/spaces/src/benchmarking.rs create mode 100644 pallets/spaces/src/lib.rs create mode 100644 pallets/spaces/src/rpc.rs create mode 100644 pallets/spaces/src/types.rs create mode 100644 pallets/spaces/src/weights.rs create mode 100644 pallets/spaces/tests/Cargo.toml create mode 100644 pallets/spaces/tests/src/lib.rs create mode 100644 pallets/spaces/tests/src/mock.rs create mode 100644 pallets/spaces/tests/src/tests.rs create mode 100644 pallets/spaces/tests/src/tests_utils.rs create mode 100644 pallets/support/Cargo.toml create mode 100644 pallets/support/src/lib.rs create mode 100644 pallets/support/src/traits.rs create mode 100644 pallets/support/src/traits/common.rs create mode 100644 pallets/support/src/traits/moderation.rs diff --git a/Cargo.lock b/Cargo.lock index 930c8e1..20eb404 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4246,6 +4246,39 @@ dependencies = [ "sp-std", ] +[[package]] +name = "pallet-permissions" +version = "0.1.7" +dependencies = [ + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "serde", + "sp-runtime", + "sp-std", + "subsocial-support", +] + +[[package]] +name = "pallet-posts" +version = "0.1.7" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "pallet-permissions", + "pallet-space-follows", + "pallet-spaces", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "serde", + "sp-runtime", + "sp-std", + "subsocial-support", +] + [[package]] name = "pallet-randomness-collective-flip" version = "4.0.0-dev" @@ -4260,6 +4293,27 @@ dependencies = [ "sp-std", ] +[[package]] +name = "pallet-roles" +version = "0.1.7" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "pallet-balances", + "pallet-permissions", + "pallet-spaces", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "serde", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", + "subsocial-support", +] + [[package]] name = "pallet-session" version = "4.0.0-dev" @@ -4281,6 +4335,37 @@ dependencies = [ "sp-trie", ] +[[package]] +name = "pallet-space-follows" +version = "0.1.7" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "pallet-spaces", + "parity-scale-codec", + "scale-info", + "sp-std", + "subsocial-support", +] + +[[package]] +name = "pallet-spaces" +version = "0.1.7" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "impl-trait-for-tuples", + "pallet-permissions", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "sp-runtime", + "sp-std", + "subsocial-support", +] + [[package]] name = "pallet-sudo" version = "4.0.0-dev" @@ -7524,6 +7609,19 @@ dependencies = [ "webrtc-util", ] +[[package]] +name = "subsocial-support" +version = "0.1.7" +dependencies = [ + "frame-support", + "frame-system", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "sp-std", + "strum", +] + [[package]] name = "substrate-bip39" version = "0.4.4" @@ -9327,7 +9425,12 @@ dependencies = [ "pallet-aura", "pallet-balances", "pallet-grandpa", + "pallet-permissions", + "pallet-posts", "pallet-randomness-collective-flip", + "pallet-roles", + "pallet-space-follows", + "pallet-spaces", "pallet-sudo", "pallet-template", "pallet-timestamp", diff --git a/Cargo.toml b/Cargo.toml index 538fd8d..c1f1230 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [workspace] members = [ "node", - "pallets/template", + "pallets/*", "runtime", ] [profile.release] diff --git a/node/src/chain_spec.rs b/node/src/chain_spec.rs index 20141cb..a52ac4c 100644 --- a/node/src/chain_spec.rs +++ b/node/src/chain_spec.rs @@ -149,8 +149,11 @@ fn testnet_genesis( }, sudo: SudoConfig { // Assign network admin rights. - key: Some(root_key), + key: Some(root_key.clone()), }, transaction_payment: Default::default(), + spaces: xsocial_runtime::SpacesConfig { + endowed_account: Some(root_key), + }, } } diff --git a/pallets/permissions/Cargo.toml b/pallets/permissions/Cargo.toml new file mode 100644 index 0000000..64931f9 --- /dev/null +++ b/pallets/permissions/Cargo.toml @@ -0,0 +1,39 @@ +[package] +name = 'pallet-permissions' +version = '0.1.7' +authors = ['DappForce '] +edition = '2021' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Permission management pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[features] +default = ['std'] +std = [ + 'serde', + 'codec/std', + 'scale-info/std', + 'sp-runtime/std', + 'frame-support/std', + 'frame-system/std', + 'sp-std/std', + 'subsocial-support/std', +] +try-runtime = ["frame-support/try-runtime"] + +[dependencies] +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } +serde = { features = ['derive'], optional = true, version = '1.0.152' } + +# Local dependencies +subsocial-support = { default-features = false, path = '../support' } + +# Substrate dependencies +frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } diff --git a/pallets/permissions/src/default_permissions.rs b/pallets/permissions/src/default_permissions.rs new file mode 100644 index 0000000..e0e758d --- /dev/null +++ b/pallets/permissions/src/default_permissions.rs @@ -0,0 +1,61 @@ +use crate::{SpacePermission as SP, SpacePermissions}; + +use frame_support::parameter_types; +use sp_std::vec; + +parameter_types! { + pub DefaultSpacePermissions: SpacePermissions = SpacePermissions { + + // No permissions disabled by default + none: None, + + everyone: Some(vec![ + SP::UpdateOwnSubspaces, + SP::DeleteOwnSubspaces, + SP::HideOwnSubspaces, + + SP::UpdateOwnPosts, + SP::DeleteOwnPosts, + SP::HideOwnPosts, + + SP::CreateComments, + SP::UpdateOwnComments, + SP::DeleteOwnComments, + SP::HideOwnComments, + + SP::Upvote, + SP::Downvote, + SP::Share, + ].into_iter().collect()), + + // Followers can do everything that everyone else can. + follower: None, + + space_owner: Some(vec![ + SP::ManageRoles, + SP::RepresentSpaceInternally, + SP::RepresentSpaceExternally, + SP::OverrideSubspacePermissions, + SP::OverridePostPermissions, + + SP::CreateSubspaces, + SP::CreatePosts, + + SP::UpdateSpace, + SP::UpdateAnySubspace, + SP::UpdateAnyPost, + + SP::DeleteAnySubspace, + SP::DeleteAnyPost, + + SP::HideAnySubspace, + SP::HideAnyPost, + SP::HideAnyComment, + + SP::SuggestEntityStatus, + SP::UpdateEntityStatus, + + SP::UpdateSpaceSettings, + ].into_iter().collect()), + }; +} diff --git a/pallets/permissions/src/lib.rs b/pallets/permissions/src/lib.rs new file mode 100644 index 0000000..7f87ff7 --- /dev/null +++ b/pallets/permissions/src/lib.rs @@ -0,0 +1,91 @@ +#![cfg_attr(not(feature = "std"), no_std)] + +pub use pallet::*; + +#[cfg(feature = "std")] +use serde::{Deserialize, Serialize}; + +use sp_std::collections::btree_set::BTreeSet; + +pub mod default_permissions; +mod types; + +pub use types::*; + +#[frame_support::pallet] +pub mod pallet { + use super::*; + + use frame_support::pallet_prelude::*; + + #[pallet::pallet] + pub struct Pallet(_); + + #[pallet::config] + pub trait Config: frame_system::Config { + #[pallet::constant] + type DefaultSpacePermissions: Get; + } + + impl Pallet { + fn get_overrides_or_defaults( + overrides: Option, + defaults: Option, + ) -> Option { + if overrides.is_some() { + overrides + } else { + defaults + } + } + + fn resolve_space_perms(space_perms: Option) -> SpacePermissions { + let defaults = T::DefaultSpacePermissions::get(); + let overrides = space_perms.unwrap_or_default(); + + SpacePermissions { + none: Self::get_overrides_or_defaults(overrides.none, defaults.none), + everyone: Self::get_overrides_or_defaults(overrides.everyone, defaults.everyone), + follower: Self::get_overrides_or_defaults(overrides.follower, defaults.follower), + space_owner: Self::get_overrides_or_defaults( + overrides.space_owner, + defaults.space_owner, + ), + } + } + + pub fn has_user_a_space_permission( + ctx: SpacePermissionsContext, + permission: SpacePermission, + ) -> Option { + let perms_by_role = Self::resolve_space_perms(ctx.space_perms); + + // Check if this permission is forbidden: + if permission.is_present_in_role(perms_by_role.none) { + return Some(false) + } + + let is_space_owner = ctx.is_space_owner; + let is_follower = is_space_owner || ctx.is_space_follower; + + if permission.is_present_in_role(perms_by_role.everyone) || + is_follower && permission.is_present_in_role(perms_by_role.follower) || + is_space_owner && permission.is_present_in_role(perms_by_role.space_owner) + { + return Some(true) + } + + None + } + + pub fn override_permissions(mut overrides: SpacePermissions) -> SpacePermissions { + overrides.none = overrides.none.map(|mut none_permissions_set| { + none_permissions_set + .extend(T::DefaultSpacePermissions::get().none.unwrap_or_default()); + none_permissions_set + }); + + overrides + } + } +} diff --git a/pallets/permissions/src/types.rs b/pallets/permissions/src/types.rs new file mode 100644 index 0000000..a05b087 --- /dev/null +++ b/pallets/permissions/src/types.rs @@ -0,0 +1,143 @@ +use codec::{Decode, Encode}; +use frame_support::dispatch::{DispatchError, DispatchResult}; +use scale_info::TypeInfo; +use sp_runtime::RuntimeDebug; + +use subsocial_support::{SpaceId, SpacePermissionsInfo, User}; + +use super::*; + +pub type SpacePermissionsInfoOf = +SpacePermissionsInfo<::AccountId, SpacePermissions>; + +#[derive(Encode, Decode, Ord, PartialOrd, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] +pub enum SpacePermission { + /// Create, update, delete, grant and revoke roles in this space. + ManageRoles, + + /// Act on behalf of this space within this space. + RepresentSpaceInternally, + /// Act on behalf of this space outside of this space. + RepresentSpaceExternally, + + /// Update this space. + UpdateSpace, + + // Related to subspaces in this space: + CreateSubspaces, + UpdateOwnSubspaces, + DeleteOwnSubspaces, + HideOwnSubspaces, + + UpdateAnySubspace, + DeleteAnySubspace, + HideAnySubspace, + + // Related to posts in this space: + CreatePosts, + UpdateOwnPosts, + DeleteOwnPosts, + HideOwnPosts, + + UpdateAnyPost, + DeleteAnyPost, + HideAnyPost, + + // Related to comments in this space: + CreateComments, + UpdateOwnComments, + DeleteOwnComments, + HideOwnComments, + + // NOTE: It was made on purpose that it's not possible to update or delete not own comments. + // Instead it's possible to allow to hide and block comments. + HideAnyComment, + + /// Upvote any post or comment in this space. + Upvote, + /// Downvote any post or comment in this space. + Downvote, + /// Share any post or comment from this space to another outer space. + Share, + + /// Override permissions per subspace in this space. + OverrideSubspacePermissions, + /// Override permissions per post in this space. + OverridePostPermissions, + + // Related to the moderation pallet: + /// Suggest new entity status in space (whether it's blocked or allowed) + SuggestEntityStatus, + /// Update entity status in space + UpdateEntityStatus, + + // Related to space settings: + /// Allows to update space settings across different pallets. + UpdateSpaceSettings, +} + +pub type SpacePermissionSet = BTreeSet; + +/// These are a set of built-in roles which can be given different permissions within a given space. +/// For example: everyone can comment (`CreateComments`), but only followers can post +/// (`CreatePosts`). +#[derive(Encode, Decode, Default, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] +pub struct SpacePermissions { + /// None represents a set of permissions which is not capable of being performed by anyone. + /// For example, if you want to create a space similar to Twitter, you would set the + /// permissions for `UpdateOwnPosts`, `UpdateOwnComments`, and `Downvote` to `none`. + pub none: Option, + + /// Everyone represents a set of permissions which are capable of being performed by every + /// account in a given space. + pub everyone: Option, + + /// Follower represents a set of permissions which are capable of being performed by every + /// account that follows a given space. + pub follower: Option, + + /// Space owner represents a set of permissions which are capable of being performed by an + /// account that is a current owner of a given space. + pub space_owner: Option, +} + +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +pub struct SpacePermissionsContext { + pub space_id: SpaceId, + pub is_space_owner: bool, + pub is_space_follower: bool, + pub space_perms: Option, +} + +impl SpacePermission { + pub(super) fn is_present_in_role(&self, perms_opt: Option) -> bool { + if let Some(perms) = perms_opt { + if perms.contains(self) { + return true + } + } + false + } +} + +pub trait PermissionChecker { + type AccountId; + + fn ensure_user_has_space_permission( + user: User, + ctx: SpacePermissionsContext, + permission: SpacePermission, + error: DispatchError, + ) -> DispatchResult; + + fn ensure_account_has_space_permission( + account: Self::AccountId, + ctx: SpacePermissionsContext, + permission: SpacePermission, + error: DispatchError, + ) -> DispatchResult { + Self::ensure_user_has_space_permission(User::Account(account), ctx, permission, error) + } +} diff --git a/pallets/posts/Cargo.toml b/pallets/posts/Cargo.toml new file mode 100644 index 0000000..f25f9a5 --- /dev/null +++ b/pallets/posts/Cargo.toml @@ -0,0 +1,50 @@ +[package] +name = 'pallet-posts' +version = '0.1.7' +authors = ['DappForce '] +edition = '2021' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Post management pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[features] +default = ['std'] +runtime-benchmarks = ['frame-benchmarking/runtime-benchmarks'] +std = [ + 'serde', + 'codec/std', + 'scale-info/std', + 'frame-benchmarking/std', + 'frame-support/std', + 'frame-system/std', + 'pallet-timestamp/std', + 'sp-runtime/std', + 'sp-std/std', + 'pallet-permissions/std', + 'pallet-space-follows/std', + 'pallet-spaces/std', + 'subsocial-support/std', +] +try-runtime = ['frame-support/try-runtime'] + +[dependencies] +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } +serde = { features = ['derive'], optional = true, version = '1.0.152' } + +# Local dependencies +pallet-permissions = { default-features = false, path = '../permissions' } +pallet-space-follows = { default-features = false, path = '../space-follows' } +pallet-spaces = { default-features = false, path = '../spaces' } +subsocial-support = { default-features = false, path = '../support' } + +# Substrate dependencies +frame-benchmarking = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false, optional = true } +frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } diff --git a/pallets/posts/rpc/Cargo.toml b/pallets/posts/rpc/Cargo.toml new file mode 100644 index 0000000..69ef41e --- /dev/null +++ b/pallets/posts/rpc/Cargo.toml @@ -0,0 +1,43 @@ +[package] +name = 'posts-rpc' +version = '0.7.3' +authors = ['DappForce '] +edition = '2018' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'RPC methods for the posts pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[dependencies] +codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false, features = ["derive"] } +serde = { features = ['derive'], optional = true, version = '1.0.119' } + +jsonrpc-core = '18.0.0' +jsonrpc-core-client = '18.0.0' +jsonrpc-derive = '18.0.0' + +# Local dependencies +pallet-posts = { default-features = false, path = '..' } +pallet-utils = { default-features = false, path = '../../utils' } + +# Custom Runtime API +posts-runtime-api = { default-features = false, path = 'runtime-api' } + +# Substrate dependencies +sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-blockchain = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-rpc = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } + +[features] +default = ['std'] +std = [ + 'serde', + 'sp-runtime/std', + 'sp-api/std', + 'posts-runtime-api/std', + 'pallet-utils/std', + 'pallet-posts/std', +] diff --git a/pallets/posts/rpc/runtime-api/Cargo.toml b/pallets/posts/rpc/runtime-api/Cargo.toml new file mode 100644 index 0000000..e23f98b --- /dev/null +++ b/pallets/posts/rpc/runtime-api/Cargo.toml @@ -0,0 +1,35 @@ +[package] +name = 'posts-runtime-api' +version = '0.7.3' +authors = ['DappForce '] +edition = '2018' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Runtime API definition for the posts pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[dependencies] +codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false, features = ["derive"] } +serde = { features = ['derive'], optional = true, version = '1.0.119' } + +# Local dependencies +pallet-posts = { default-features = false, path = '../..' } +pallet-utils = { default-features = false, path = '../../../utils' } + +# Substrate dependencies +sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } + +[features] +default = ['std'] +std = [ + 'serde', + 'sp-api/std', + 'sp-std/std', + 'sp-runtime/std', + 'pallet-utils/std', + 'pallet-posts/std', +] diff --git a/pallets/posts/rpc/runtime-api/src/lib.rs b/pallets/posts/rpc/runtime-api/src/lib.rs new file mode 100644 index 0000000..fbe359e --- /dev/null +++ b/pallets/posts/rpc/runtime-api/src/lib.rs @@ -0,0 +1,39 @@ +#![cfg_attr(not(feature = "std"), no_std)] + +use codec::Codec; +use sp_std::collections::btree_map::BTreeMap; +use sp_std::vec::Vec; + +use pallet_posts::rpc::{FlatPost, FlatPostKind, RepliesByPostId}; +use pallet_utils::{PostId, SpaceId}; + +sp_api::decl_runtime_apis! { + pub trait PostsApi where + AccountId: Codec, + BlockNumber: Codec + { + fn get_next_post_id() -> PostId; + + fn get_posts_by_ids(post_ids: Vec, offset: u64, limit: u16) -> Vec>; + + fn get_public_posts(kind_filter: Vec, offset: u64, limit: u16) -> Vec>; + + fn get_public_posts_by_space_id(space_id: SpaceId, offset: u64, limit: u16) -> Vec>; + + fn get_unlisted_posts_by_space_id(space_id: SpaceId, offset: u64, limit: u16) -> Vec>; + + fn get_public_post_ids_by_space_id(space_id: SpaceId) -> Vec; + + fn get_unlisted_post_ids_by_space_id(space_id: SpaceId) -> Vec; + + fn get_reply_ids_by_parent_id(parent_id: PostId) -> Vec; + + fn get_reply_ids_by_parent_ids(parent_ids: Vec) -> BTreeMap>; + + fn get_replies_by_parent_id(parent_id: PostId, offset: u64, limit: u16) -> Vec>; + + fn get_replies_by_parent_ids(parent_ids: Vec, offset: u64, limit: u16) -> RepliesByPostId; + + fn get_feed(account: AccountId, offset: u64, limit: u16) -> Vec>; + } +} diff --git a/pallets/posts/rpc/src/lib.rs b/pallets/posts/rpc/src/lib.rs new file mode 100644 index 0000000..0028f40 --- /dev/null +++ b/pallets/posts/rpc/src/lib.rs @@ -0,0 +1,270 @@ +use std::{sync::Arc, collections::BTreeMap}; +use codec::Codec; +use sp_blockchain::HeaderBackend; +use sp_runtime::{generic::BlockId, traits::Block as BlockT}; +use jsonrpc_core::Result; +use jsonrpc_derive::rpc; +use sp_api::ProvideRuntimeApi; + +use pallet_posts::rpc::{FlatPost, FlatPostKind, RepliesByPostId}; +use pallet_utils::{PostId, SpaceId, rpc::map_rpc_error}; +pub use posts_runtime_api::PostsApi as PostsRuntimeApi; + +#[rpc] +pub trait PostsApi { + #[rpc(name = "posts_getPostsByIds")] + fn get_posts_by_ids( + &self, + at: Option, + post_ids: Vec, + offset: u64, + limit: u16, + ) -> Result>>; + + #[rpc(name = "posts_getPublicPosts")] + fn get_public_posts( + &self, + at: Option, + kind_filter: Vec, + start_id: u64, + limit: u16 + ) -> Result>>; + + #[rpc(name = "posts_getPublicPostsBySpaceId")] + fn get_public_posts_by_space_id( + &self, + at: Option, + space_id: SpaceId, + offset: u64, + limit: u16, + ) -> Result>>; + + #[rpc(name = "posts_getUnlistedPostsBySpaceId")] + fn get_unlisted_posts_by_space_id( + &self, + at: Option, + space_id: SpaceId, + offset: u64, + limit: u16, + ) -> Result>>; + + #[rpc(name = "posts_getReplyIdsByParentId")] + fn get_reply_ids_by_parent_id( + &self, + at: Option, + post_id: PostId, + ) -> Result>; + + #[rpc(name = "posts_getReplyIdsByParentIds")] + fn get_reply_ids_by_parent_ids( + &self, + at: Option, + post_ids: Vec, + ) -> Result>>; + + #[rpc(name = "posts_getRepliesByParentId")] + fn get_replies_by_parent_id( + &self, + at: Option, + parent_id: PostId, + offset: u64, + limit: u16, + ) -> Result>>; + + #[rpc(name = "posts_getRepliesByParentIds")] + fn get_replies_by_parent_ids( + &self, + at: Option, + parent_ids: Vec, + offset: u64, + limit: u16, + ) -> Result>; + + #[rpc(name = "posts_getUnlistedPostIdsBySpaceId")] + fn get_unlisted_post_ids_by_space_id( + &self, + at: Option, + space_id: SpaceId, + ) -> Result>; + + #[rpc(name = "posts_getPublicPostIdsBySpaceId")] + fn get_public_post_ids_by_space_id( + &self, + at: Option, + space_id: SpaceId, + ) -> Result>; + + #[rpc(name = "posts_nextPostId")] + fn get_next_post_id(&self, at: Option) -> Result; + + #[rpc(name = "posts_getFeed")] + fn get_feed( + &self, + at: Option, + account: AccountId, + offset: u64, + limit: u16, + ) -> Result>>; +} + +pub struct Posts { + client: Arc, + _marker: std::marker::PhantomData, +} + +impl Posts { + pub fn new(client: Arc) -> Self { + Self { + client, + _marker: Default::default(), + } + } +} + +impl PostsApi<::Hash, AccountId, BlockNumber> + for Posts +where + Block: BlockT, + AccountId: Codec, + BlockNumber: Codec, + C: Send + Sync + 'static + ProvideRuntimeApi + HeaderBackend, + C::Api: PostsRuntimeApi, +{ + fn get_posts_by_ids( + &self, + at: Option<::Hash>, + post_ids: Vec, + offset: u64, + limit: u16, + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_posts_by_ids(&at, post_ids, offset, limit); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_public_posts( + &self, + at: Option<::Hash>, + kind_filter: Vec, + start_id: u64, + limit: u16 + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_public_posts(&at, kind_filter, start_id, limit); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_public_posts_by_space_id( + &self, + at: Option<::Hash>, + space_id: u64, + offset: u64, + limit: u16, + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_public_posts_by_space_id(&at, space_id, offset, limit); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_unlisted_posts_by_space_id( + &self, + at: Option<::Hash>, + space_id: u64, + offset: u64, + limit: u16, + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_unlisted_posts_by_space_id(&at, space_id, offset, limit); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_reply_ids_by_parent_id(&self, at: Option<::Hash>, parent_id: PostId) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_reply_ids_by_parent_id(&at, parent_id); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_reply_ids_by_parent_ids(&self, at: Option<::Hash>, parent_ids: Vec) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_reply_ids_by_parent_ids(&at, parent_ids); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_replies_by_parent_id( + &self, + at: Option<::Hash>, + parent_id: PostId, + offset: u64, + limit: u16 + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_replies_by_parent_id(&at, parent_id, offset, limit); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_replies_by_parent_ids( + &self, + at: Option<::Hash>, + parent_ids: Vec, + offset: u64, + limit: u16 + ) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_replies_by_parent_ids(&at, parent_ids, offset, limit); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_unlisted_post_ids_by_space_id(&self, at: Option<::Hash>, space_id: u64) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_unlisted_post_ids_by_space_id(&at, space_id); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_public_post_ids_by_space_id(&self, at: Option<::Hash>, space_id: u64) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_public_post_ids_by_space_id(&at, space_id); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_next_post_id(&self, at: Option<::Hash>) -> Result { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_next_post_id(&at); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_feed( + &self, + at: Option<::Hash>, + account: AccountId, + offset: u64, + limit: u16 + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_feed(&at, account, offset, limit); + runtime_api_result.map_err(map_rpc_error) + } +} diff --git a/pallets/posts/src/benchmarking.rs b/pallets/posts/src/benchmarking.rs new file mode 100644 index 0000000..1a29291 --- /dev/null +++ b/pallets/posts/src/benchmarking.rs @@ -0,0 +1,147 @@ +#![cfg(feature = "runtime-benchmarks")] + +use super::*; +use frame_benchmarking::{benchmarks, whitelisted_caller}; +use frame_support::dispatch::DispatchError; +use frame_system::RawOrigin; +use pallet_spaces::types::Space; +use subsocial_support::Content; + +fn create_dummy_space( + origin: RawOrigin, +) -> Result, DispatchError> { + let space_id = pallet_spaces::NextSpaceId::::get(); + + pallet_spaces::Pallet::::create_space(origin.into(), Content::None, None)?; + + let space = pallet_spaces::SpaceById::::get(space_id) + .ok_or(DispatchError::Other("Space not found"))?; + + Ok(space) +} + +fn create_dummy_post( + origin: RawOrigin, + space: Space, +) -> Result, DispatchError> { + let post_id = NextPostId::::get(); + + Pallet::::create_post( + origin.into(), + Some(space.id), + PostExtension::RegularPost, + Content::None, + )?; + + let post = PostById::::get(post_id).ok_or(DispatchError::Other("Post wasn't created"))?; + + Ok(post) +} + +fn create_dummy_reply( + origin: RawOrigin, + space: Space, + post: Post, +) -> Result, DispatchError> { + let post_id = NextPostId::::get(); + + Pallet::::create_post( + origin.into(), + Some(space.id), + PostExtension::Comment(Comment { parent_id: None, root_post_id: post.id }), + Content::None, + )?; + + let post = PostById::::get(post_id).ok_or(DispatchError::Other("Reply wasn't created"))?; + + Ok(post) +} + +benchmarks! { + create_post__regular { + let origin = RawOrigin::Signed(whitelisted_caller()); + let space = create_dummy_space::(origin.clone())?; + let post_id = NextPostId::::get(); + + }: create_post(origin, Some(space.id), PostExtension::RegularPost, Content::None) + verify { + let post = PostById::::get(post_id) + .ok_or(DispatchError::Other("Post wasn't created"))?; + + ensure!(post.space_id == Some(space.id), "Post wasn't created in the right space"); + ensure!(post.extension == PostExtension::RegularPost, "Post wasn't created with the right extension"); + } + + create_post__shared { + let origin = RawOrigin::Signed(whitelisted_caller()); + let space = create_dummy_space::(origin.clone())?; + let original_post = create_dummy_post::(origin.clone(), space.clone())?; + let post_id = NextPostId::::get(); + + }: create_post(origin, Some(space.id), PostExtension::SharedPost(original_post.id), Content::None) + verify { + let post = PostById::::get(post_id) + .ok_or(DispatchError::Other("Post wasn't created"))?; + + ensure!(post.space_id == Some(space.id), "Post wasn't created in the right space"); + ensure!(post.extension == PostExtension::SharedPost(original_post.id), "Post wasn't created with the right extension"); + } + + create_post__comment { + let origin = RawOrigin::Signed(whitelisted_caller()); + let space = create_dummy_space::(origin.clone())?; + let original_post = create_dummy_post::(origin.clone(), space.clone())?; + let reply = create_dummy_reply::(origin.clone(), space.clone(), original_post.clone())?; + let post_id = NextPostId::::get(); + + let ext = PostExtension::Comment(Comment { + parent_id: Some(reply.id), + root_post_id: original_post.id, + }); + }: create_post(origin, Some(space.id), ext, Content::None) + verify { + let post = PostById::::get(post_id) + .ok_or(DispatchError::Other("Reply wasn't created"))?; + + ensure!(post.space_id == Some(space.id), "Reply wasn't created in the right space"); + ensure!(post.extension == ext, "Post wasn't created with the right extension"); + } + + + update_post { + let origin = RawOrigin::Signed(whitelisted_caller()); + let space = create_dummy_space::(origin.clone())?; + let post = create_dummy_post::(origin.clone(), space.clone())?; + let reply = create_dummy_reply::(origin.clone(), space, post.clone())?; + + let new_content = Content::IPFS(b"Qme7ss3ARVgxv6rXqVPiikMJ8u2NLgmgszg13pYrDKEoiu".to_vec()); + + let update = PostUpdate { + hidden: Some(true), + content: Some(new_content.clone()), + space_id: None, + }; + }: update_post(origin, reply.id, update) + verify { + let updated_post = PostById::::get(reply.id) + .ok_or(DispatchError::Other("Post wasn't found"))?; + + ensure!(updated_post != post, "Post wasn't updated"); + ensure!(updated_post.hidden, "Post hidden status wasn't updated"); + ensure!(updated_post.content == new_content, "Post content wasn't updated"); + } + + move_post { + let origin = RawOrigin::Signed(whitelisted_caller()); + let space = create_dummy_space::(origin.clone())?; + let post = create_dummy_post::(origin.clone(), space)?; + + let new_space = create_dummy_space::(origin.clone())?; + }: move_post(origin, post.id, Some(new_space.id)) + verify { + let moved_post = PostById::::get(post.id) + .ok_or(DispatchError::Other("Post wasn't found"))?; + + ensure!(moved_post.space_id == Some(new_space.id), "Post wasn't moved"); + } +} diff --git a/pallets/posts/src/functions.rs b/pallets/posts/src/functions.rs new file mode 100644 index 0000000..2e0efff --- /dev/null +++ b/pallets/posts/src/functions.rs @@ -0,0 +1,337 @@ +use frame_support::dispatch::DispatchResult; +use sp_runtime::traits::Saturating; + +use subsocial_support::{remove_from_vec, SpaceId}; + +use super::*; + +impl Post { + pub fn new( + id: PostId, + created_by: T::AccountId, + space_id_opt: Option, + extension: PostExtension, + content: Content, + ) -> Self { + Post { + id, + created: new_who_and_when::(created_by.clone()), + edited: false, + owner: created_by, + extension, + space_id: space_id_opt, + content, + hidden: false, + upvotes_count: 0, + downvotes_count: 0, + } + } + + pub fn ensure_owner(&self, account: &T::AccountId) -> DispatchResult { + ensure!(self.is_owner(account), Error::::NotAPostOwner); + Ok(()) + } + + pub fn is_owner(&self, account: &T::AccountId) -> bool { + self.owner == *account + } + + pub fn is_root_post(&self) -> bool { + !self.is_comment() + } + + pub fn is_regular_post(&self) -> bool { + matches!(self.extension, PostExtension::RegularPost) + } + + pub fn is_comment(&self) -> bool { + matches!(self.extension, PostExtension::Comment(_)) + } + + pub fn is_shared_post(&self) -> bool { + matches!(self.extension, PostExtension::SharedPost(_)) + } + + pub fn get_comment_ext(&self) -> Result { + match self.extension { + PostExtension::Comment(comment_ext) => Ok(comment_ext), + _ => Err(Error::::NotComment.into()), + } + } + + pub fn get_original_post_id(&self) -> Result { + match self.extension { + PostExtension::SharedPost(original_post_id) => Ok(original_post_id), + _ => Err(Error::::NotASharedPost.into()), + } + } + + pub fn get_root_post(&self) -> Result, DispatchError> { + match self.extension { + PostExtension::RegularPost | PostExtension::SharedPost(_) => Ok(self.clone()), + PostExtension::Comment(comment) => Pallet::::require_post(comment.root_post_id), + } + } + + pub fn get_space_id(&self) -> Result { + Self::try_get_space_id(self).ok_or_else(|| Error::::PostHasNoSpaceId.into()) + } + + pub fn try_get_space_id(&self) -> Option { + if let Ok(root_post) = self.get_root_post() { + return root_post.space_id + } + + None + } + + pub fn get_space(&self) -> Result, DispatchError> { + let root_post = self.get_root_post()?; + let space_id = root_post.space_id.ok_or(Error::::PostHasNoSpaceId)?; + Spaces::require_space(space_id) + } + + pub fn try_get_space(&self) -> Option> { + if let Ok(root_post) = self.get_root_post() { + return root_post.space_id.and_then(|space_id| Spaces::require_space(space_id).ok()) + } + + None + } + + pub fn try_get_parent_id(&self) -> Option { + match self.extension { + PostExtension::Comment(comment_ext) => comment_ext.parent_id, + _ => None, + } + } + + pub fn inc_upvotes(&mut self) { + self.upvotes_count.saturating_inc(); + } + + pub fn dec_upvotes(&mut self) { + self.upvotes_count.saturating_dec(); + } + + pub fn inc_downvotes(&mut self) { + self.downvotes_count.saturating_inc(); + } + + pub fn dec_downvotes(&mut self) { + self.downvotes_count.saturating_dec(); + } + + pub fn is_public(&self) -> bool { + !self.hidden && self.content.is_some() + } + + pub fn is_unlisted(&self) -> bool { + !self.is_public() + } +} + +impl Pallet { + pub fn ensure_account_can_update_post( + editor: &T::AccountId, + post: &Post, + space: &Space, + ) -> DispatchResult { + let is_owner = post.is_owner(editor); + let is_comment = post.is_comment(); + + let permission_to_check: SpacePermission; + let permission_error: DispatchError; + + if is_comment { + if is_owner { + permission_to_check = SpacePermission::UpdateOwnComments; + permission_error = Error::::NoPermissionToUpdateOwnComments.into(); + } else { + fail!(Error::::NotACommentAuthor); + } + } else { + // Not a comment + + if is_owner { + permission_to_check = SpacePermission::UpdateOwnPosts; + permission_error = Error::::NoPermissionToUpdateOwnPosts.into(); + } else { + permission_to_check = SpacePermission::UpdateAnyPost; + permission_error = Error::::NoPermissionToUpdateAnyPost.into(); + } + } + + Spaces::ensure_account_has_space_permission( + editor.clone(), + space, + permission_to_check, + permission_error, + ) + } + + /// Check that there is a `Post` with such `post_id` in the storage + /// or return`PostNotFound` error. + pub fn ensure_post_exists(post_id: PostId) -> DispatchResult { + ensure!(PostById::::contains_key(post_id), Error::::PostNotFound); + Ok(()) + } + + /// Get `Post` by id from the storage or return `PostNotFound` error. + pub fn require_post(post_id: SpaceId) -> Result, DispatchError> { + Ok(Self::post_by_id(post_id).ok_or(Error::::PostNotFound)?) + } + + pub fn is_root_post_hidden(post_id: PostId) -> Result { + let post = Self::require_post(post_id)?; + let root_post = post.get_root_post()?; + Ok(root_post.hidden) + } + + pub fn is_root_post_visible(post_id: PostId) -> Result { + Self::is_root_post_hidden(post_id).map(|v| !v) + } + + pub fn mutate_post_by_id)>( + post_id: PostId, + f: F, + ) -> Result, DispatchError> { + PostById::::mutate(post_id, |post_opt| { + if let Some(ref mut post) = post_opt.clone() { + f(post); + *post_opt = Some(post.clone()); + + return Ok(post.clone()) + } + + Err(Error::::PostNotFound.into()) + }) + } + + // TODO refactor to a tail recursion + /// Get all post ancestors (parent_id) including this post + pub fn get_post_ancestors(post_id: PostId) -> Vec> { + let mut ancestors: Vec> = Vec::new(); + + if let Some(post) = Self::post_by_id(post_id) { + ancestors.push(post.clone()); + if let Some(parent_id) = post.get_comment_ext().ok().unwrap().parent_id { + ancestors.extend(Self::get_post_ancestors(parent_id).iter().cloned()); + } + } + + ancestors + } + + pub(crate) fn create_comment( + new_post_id: PostId, + comment_ext: Comment, + root_post_id: PostId, + ) -> DispatchResult { + let mut commented_post_id = root_post_id; + + if let Some(parent_id) = comment_ext.parent_id { + let parent_comment = + Self::post_by_id(parent_id).ok_or(Error::::UnknownParentComment)?; + + ensure!(parent_comment.is_comment(), Error::::NotACommentByParentId); + + let ancestors = Self::get_post_ancestors(parent_id); + ensure!( + ancestors.len() < T::MaxCommentDepth::get() as usize, + Error::::MaxCommentDepthReached + ); + + commented_post_id = parent_id; + } + + ReplyIdsByPostId::::mutate(commented_post_id, |reply_ids| reply_ids.push(new_post_id)); + + Ok(()) + } + + pub(crate) fn create_shared_post( + creator: &T::AccountId, + new_post_id: PostId, + original_post_id: PostId, + ) -> DispatchResult { + let original_post = + &mut Self::post_by_id(original_post_id).ok_or(Error::::OriginalPostNotFound)?; + + ensure!(!original_post.is_shared_post(), Error::::CannotShareSharedPost); + + // Check if it's allowed to share a post from the space of original post. + Spaces::ensure_account_has_space_permission( + creator.clone(), + &original_post.get_space()?, + SpacePermission::Share, + Error::::NoPermissionToShare.into(), + )?; + + SharedPostIdsByOriginalPostId::::mutate(original_post_id, |ids| ids.push(new_post_id)); + Ok(()) + } + + pub(crate) fn move_post_to_space( + editor: T::AccountId, + post: &mut Post, + new_space_id: SpaceId, + ) -> DispatchResult { + let old_space_id_opt = post.try_get_space_id(); + let new_space = Spaces::::require_space(new_space_id)?; + + ensure!( + T::IsAccountBlocked::is_allowed_account(editor.clone(), new_space_id), + ModerationError::AccountIsBlocked + ); + Spaces::ensure_account_has_space_permission( + editor, + &new_space, + SpacePermission::CreatePosts, + Error::::NoPermissionToCreatePosts.into(), + )?; + ensure!( + T::IsPostBlocked::is_allowed_post(post.id, new_space_id), + ModerationError::PostIsBlocked + ); + ensure!( + T::IsContentBlocked::is_allowed_content(post.content.clone(), new_space_id), + ModerationError::ContentIsBlocked + ); + + match post.extension { + PostExtension::RegularPost | PostExtension::SharedPost(_) => { + if let Some(old_space_id) = old_space_id_opt { + PostIdsBySpaceId::::mutate(old_space_id, |post_ids| { + remove_from_vec(post_ids, post.id) + }); + } + + PostIdsBySpaceId::::mutate(new_space_id, |post_ids| post_ids.push(post.id)); + + post.space_id = Some(new_space_id); + PostById::::insert(post.id, post); + + Ok(()) + }, + _ => fail!(Error::::CannotUpdateSpaceIdOnComment), + } + } + + pub fn delete_post_from_space(post_id: PostId) -> DispatchResult { + let mut post = Self::require_post(post_id)?; + + if post.is_comment() { + post.extension = PostExtension::RegularPost; + } else { + let space_id = post.get_space_id()?; + + post.space_id = None; + PostIdsBySpaceId::::mutate(space_id, |post_ids| remove_from_vec(post_ids, post_id)); + } + + PostById::insert(post.id, post); + + Ok(()) + } +} diff --git a/pallets/posts/src/lib.rs b/pallets/posts/src/lib.rs new file mode 100644 index 0000000..e4d611e --- /dev/null +++ b/pallets/posts/src/lib.rs @@ -0,0 +1,485 @@ +//! # Posts Module +//! +//! Posts are the second crucial component of Subsocial after Spaces. This module allows you to +//! create, update, move (between spaces), and hide posts as well as manage owner(s). +//! +//! Posts can be compared to existing entities on web 2.0 platforms such as: +//! - Posts on Facebook, +//! - Tweets on Twitter, +//! - Images on Instagram, +//! - Articles on Medium, +//! - Shared links on Reddit, +//! - Questions and answers on Stack Overflow. + +#![cfg_attr(not(feature = "std"), no_std)] + +use codec::{Decode, Encode}; +use frame_support::{ + dispatch::{DispatchError, DispatchResult}, + ensure, fail, + traits::Get, +}; +use frame_system::ensure_signed; +use scale_info::TypeInfo; +#[cfg(feature = "std")] +use serde::{Deserialize, Serialize}; +use sp_runtime::RuntimeDebug; +use sp_std::prelude::*; + +use pallet_permissions::SpacePermission; +use pallet_spaces::{types::Space, Pallet as Spaces}; +use subsocial_support::{ + ensure_content_is_valid, new_who_and_when, remove_from_vec, + traits::{IsAccountBlocked, IsContentBlocked, IsPostBlocked}, + Content, ModerationError, PostId, SpaceId, WhoAndWhen, WhoAndWhenOf, +}; + +pub use pallet::*; +pub mod functions; + +pub mod types; +pub use types::*; + +#[cfg(feature = "runtime-benchmarks")] +mod benchmarking; +pub mod weights; + +// pub mod rpc; + +#[frame_support::pallet] +pub mod pallet { + use super::*; + + use crate::weights::WeightInfo; + use frame_support::{pallet_prelude::*, traits::IsType}; + use frame_system::pallet_prelude::*; + + #[pallet::config] + pub trait Config: + frame_system::Config + + pallet_space_follows::Config + + pallet_spaces::Config + + pallet_timestamp::Config + { + /// The overarching event type. + type RuntimeEvent: From> + IsType<::RuntimeEvent>; + + /// Max comments depth + #[pallet::constant] + type MaxCommentDepth: Get; + + type IsPostBlocked: IsPostBlocked; + + type WeightInfo: WeightInfo; + } + + #[pallet::pallet] + #[pallet::generate_store(pub(super) trait Store)] + #[pallet::without_storage_info] + pub struct Pallet(_); + + #[pallet::type_value] + pub fn DefaultForNextPostId() -> PostId { + FIRST_POST_ID + } + + /// The next post id. + #[pallet::storage] + #[pallet::getter(fn next_post_id)] + pub type NextPostId = StorageValue<_, PostId, ValueQuery, DefaultForNextPostId>; + + /// Get the details of a post by its' id. + #[pallet::storage] + #[pallet::getter(fn post_by_id)] + pub type PostById = StorageMap<_, Twox64Concat, PostId, Post>; + + /// Get the ids of all direct replies by their parent's post id. + #[pallet::storage] + #[pallet::getter(fn reply_ids_by_post_id)] + pub type ReplyIdsByPostId = + StorageMap<_, Twox64Concat, PostId, Vec, ValueQuery>; + + /// Get the ids of all posts in a given space, by the space's id. + #[pallet::storage] + #[pallet::getter(fn post_ids_by_space_id)] + pub type PostIdsBySpaceId = + StorageMap<_, Twox64Concat, SpaceId, Vec, ValueQuery>; + + /// Get the ids of all posts that have shared a given original post id. + #[pallet::storage] + #[pallet::getter(fn shared_post_ids_by_original_post_id)] + pub type SharedPostIdsByOriginalPostId = + StorageMap<_, Twox64Concat, PostId, Vec, ValueQuery>; + + #[pallet::event] + #[pallet::generate_deposit(pub(super) fn deposit_event)] + pub enum Event { + PostCreated { + account: T::AccountId, + post_id: PostId, + }, + PostUpdated { + account: T::AccountId, + post_id: PostId, + }, + PostMoved { + account: T::AccountId, + post_id: PostId, + from_space: Option, + to_space: Option, + }, + } + + #[pallet::error] + pub enum Error { + // Post related errors: + /// Post was not found by id. + PostNotFound, + /// An account is not a post owner. + NotAPostOwner, + /// Nothing to update in this post. + NoUpdatesForPost, + /// Root post should have a space id. + PostHasNoSpaceId, + /// Not allowed to create a post/comment when a scope (space or root post) is hidden. + CannotCreateInHiddenScope, + /// Post has no replies. + NoRepliesOnPost, + /// Cannot move a post to the same space. + CannotMoveToSameSpace, + + // Share related errors: + /// Cannot share, because the original post was not found. + OriginalPostNotFound, + /// Cannot share a post that is sharing another post. + CannotShareSharedPost, + /// This post's extension is not a `SharedPost`. + NotASharedPost, + + // Comment related errors: + /// Unknown parent comment id. + UnknownParentComment, + /// Post by `parent_id` is not of a `Comment` extension. + NotACommentByParentId, + /// Cannot update space id of a comment. + CannotUpdateSpaceIdOnComment, + /// Max comment depth reached. + MaxCommentDepthReached, + /// Only comment owner can update this comment. + NotACommentAuthor, + /// This post's extension is not a `Comment`. + NotComment, + + // Permissions related errors: + /// User has no permission to create root posts in this space. + NoPermissionToCreatePosts, + /// User has no permission to create comments (aka replies) in this space. + NoPermissionToCreateComments, + /// User has no permission to share posts/comments from this space to another space. + NoPermissionToShare, + /// User has no permission to update any posts in this space. + NoPermissionToUpdateAnyPost, + /// A post owner is not allowed to update their own posts in this space. + NoPermissionToUpdateOwnPosts, + /// A comment owner is not allowed to update their own comments in this space. + NoPermissionToUpdateOwnComments, + + /// `force_create_post` failed, because this post already exists. + /// Consider removing the post with `force_remove_post` first. + PostAlreadyExists, + } + + #[pallet::call] + impl Pallet { + #[pallet::call_index(0)] + #[pallet::weight( + match extension { + PostExtension::RegularPost => ::WeightInfo::create_post__regular(), + PostExtension::Comment(..) => ::WeightInfo::create_post__comment(), + PostExtension::SharedPost(..) => ::WeightInfo::create_post__shared(), + } + )] + pub fn create_post( + origin: OriginFor, + space_id_opt: Option, + extension: PostExtension, + content: Content, + ) -> DispatchResult { + let creator = ensure_signed(origin)?; + + ensure_content_is_valid(content.clone())?; + + let new_post_id = Self::next_post_id(); + let new_post: Post = + Post::new(new_post_id, creator.clone(), space_id_opt, extension, content.clone()); + + // Get space from either space_id_opt or Comment if a comment provided + let space = &new_post.get_space()?; + ensure!(!space.hidden, Error::::CannotCreateInHiddenScope); + + ensure!( + T::IsAccountBlocked::is_allowed_account(creator.clone(), space.id), + ModerationError::AccountIsBlocked + ); + ensure!( + T::IsContentBlocked::is_allowed_content(content, space.id), + ModerationError::ContentIsBlocked + ); + + let root_post = &mut new_post.get_root_post()?; + ensure!(!root_post.hidden, Error::::CannotCreateInHiddenScope); + + // Check whether account has permission to create Post (by extension) + let mut permission_to_check = SpacePermission::CreatePosts; + let mut error_on_permission_failed = Error::::NoPermissionToCreatePosts; + + if let PostExtension::Comment(_) = extension { + permission_to_check = SpacePermission::CreateComments; + error_on_permission_failed = Error::::NoPermissionToCreateComments; + } + + Spaces::ensure_account_has_space_permission( + creator.clone(), + space, + permission_to_check, + error_on_permission_failed.into(), + )?; + + match extension { + PostExtension::SharedPost(original_post_id) => + Self::create_shared_post(&creator, new_post_id, original_post_id)?, + PostExtension::Comment(comment_ext) => + Self::create_comment(new_post_id, comment_ext, root_post.id)?, + _ => (), + } + + if new_post.is_root_post() { + PostIdsBySpaceId::::mutate(space.id, |ids| ids.push(new_post_id)); + } + + PostById::insert(new_post_id, new_post); + NextPostId::::mutate(|n| { + *n += 1; + }); + + Self::deposit_event(Event::PostCreated { account: creator, post_id: new_post_id }); + Ok(()) + } + + #[pallet::call_index(1)] + #[pallet::weight(::WeightInfo::update_post())] + pub fn update_post( + origin: OriginFor, + post_id: PostId, + update: PostUpdate, + ) -> DispatchResult { + let editor = ensure_signed(origin)?; + + let has_updates = update.content.is_some() || update.hidden.is_some(); + + ensure!(has_updates, Error::::NoUpdatesForPost); + + let mut post = Self::require_post(post_id)?; + let space_opt = &post.try_get_space(); + + if let Some(space) = space_opt { + ensure!( + T::IsAccountBlocked::is_allowed_account(editor.clone(), space.id), + ModerationError::AccountIsBlocked + ); + Self::ensure_account_can_update_post(&editor, &post, space)?; + } + + let mut is_update_applied = false; + + if let Some(content) = update.content { + if content != post.content { + ensure_content_is_valid(content.clone())?; + + if let Some(space) = space_opt { + ensure!( + T::IsContentBlocked::is_allowed_content(content.clone(), space.id), + ModerationError::ContentIsBlocked + ); + } + + post.content = content; + post.edited = true; + is_update_applied = true; + } + } + + if let Some(hidden) = update.hidden { + if hidden != post.hidden { + post.hidden = hidden; + is_update_applied = true; + } + } + + // Update this post only if at least one field should be updated: + if is_update_applied { + >::insert(post.id, post); + Self::deposit_event(Event::PostUpdated { account: editor, post_id }); + } + Ok(()) + } + + #[pallet::call_index(2)] + #[pallet::weight(::WeightInfo::move_post())] + pub fn move_post( + origin: OriginFor, + post_id: PostId, + new_space_id: Option, + ) -> DispatchResult { + let who = ensure_signed(origin)?; + + let post = &mut Self::require_post(post_id)?; + + ensure!(new_space_id != post.space_id, Error::::CannotMoveToSameSpace); + + if let Some(space) = post.try_get_space() { + Self::ensure_account_can_update_post(&who, post, &space)?; + } else { + post.ensure_owner(&who)?; + } + + let old_space_id = post.space_id; + + if let Some(space_id) = new_space_id { + Self::move_post_to_space(who.clone(), post, space_id)?; + } else { + Self::delete_post_from_space(post_id)?; + } + + Self::deposit_event(Event::PostMoved { + account: who, + post_id, + from_space: old_space_id, + to_space: new_space_id, + }); + Ok(()) + } + + #[pallet::call_index(3)] + #[pallet::weight(( + Weight::from_ref_time(50_000) + T::DbWeight::get().reads_writes(4, 3), + DispatchClass::Operational, + Pays::Yes, + ))] + pub fn force_create_post( + origin: OriginFor, + post_id: PostId, + created: WhoAndWhenOf, + owner: T::AccountId, + extension: PostExtension, + space_id_opt: Option, + content: Content, + hidden: bool, + upvotes_count: u32, + downvotes_count: u32, + ) -> DispatchResultWithPostInfo { + ensure_root(origin)?; + + ensure!(Self::require_post(post_id).is_err(), Error::::PostAlreadyExists); + + let WhoAndWhen { account, time, .. } = created; + let new_who_and_when = + WhoAndWhen { account, block: frame_system::Pallet::::block_number(), time }; + + let new_post = Post:: { + id: post_id, + created: new_who_and_when, + edited: false, + owner: owner.clone(), + extension, + space_id: space_id_opt, + content, + hidden, + upvotes_count, + downvotes_count, + }; + + if new_post.is_root_post() { + if let Some(space_id) = new_post.space_id { + PostIdsBySpaceId::::mutate(space_id, |ids| ids.push(post_id)); + } + } + + match new_post.extension { + PostExtension::Comment(ext) => { + let commented_post_id = ext.parent_id.unwrap_or(ext.root_post_id); + ReplyIdsByPostId::::mutate(commented_post_id, |reply_ids| { + reply_ids.push(post_id) + }); + }, + PostExtension::SharedPost(original_post_id) => { + SharedPostIdsByOriginalPostId::::mutate(original_post_id, |ids| { + ids.push(post_id) + }); + }, + _ => (), + } + + PostById::insert(post_id, new_post); + + Self::deposit_event(Event::PostCreated { account: owner, post_id }); + Ok(Pays::No.into()) + } + + #[pallet::call_index(4)] + #[pallet::weight(( + Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(2, 3), + DispatchClass::Operational, + Pays::Yes, + ))] + pub fn force_remove_post( + origin: OriginFor, + post_id: PostId, + ) -> DispatchResultWithPostInfo { + ensure_root(origin)?; + + if let Ok(old_post) = Self::require_post(post_id) { + if old_post.is_root_post() { + if let Some(space_id) = old_post.space_id { + PostIdsBySpaceId::::mutate(space_id, |ids| { + remove_from_vec(ids, post_id) + }); + } + } + + match old_post.extension { + PostExtension::Comment(ext) => { + let commented_post_id = ext.parent_id.unwrap_or(ext.root_post_id); + ReplyIdsByPostId::::mutate(commented_post_id, |reply_ids| { + remove_from_vec(reply_ids, post_id) + }); + }, + PostExtension::SharedPost(original_post_id) => { + SharedPostIdsByOriginalPostId::::mutate(original_post_id, |ids| { + remove_from_vec(ids, post_id) + }); + }, + _ => (), + } + PostById::::remove(post_id); + } + + Ok(Pays::No.into()) + } + + #[pallet::call_index(5)] + #[pallet::weight(( + Weight::from_ref_time(10_000) + T::DbWeight::get().writes(1), + DispatchClass::Operational, + Pays::Yes, + ))] + pub fn force_set_next_post_id( + origin: OriginFor, + post_id: PostId, + ) -> DispatchResultWithPostInfo { + ensure_root(origin)?; + NextPostId::::put(post_id); + Ok(Pays::No.into()) + } + } +} diff --git a/pallets/posts/src/rpc.rs b/pallets/posts/src/rpc.rs new file mode 100644 index 0000000..9d3fb9e --- /dev/null +++ b/pallets/posts/src/rpc.rs @@ -0,0 +1,313 @@ +use codec::{Decode, Encode}; +#[cfg(feature = "std")] +use serde::{Deserialize, Serialize}; +use sp_std::collections::{btree_map::BTreeMap, btree_set::BTreeSet}; +use sp_std::{vec, prelude::*}; + +use pallet_space_follows::Module as SpaceFollows; +use pallet_spaces::Module as Spaces; +use pallet_utils::{bool_to_option, PostId, rpc::{FlatContent, FlatWhoAndWhen, ShouldSkip}, SpaceId}; + +use crate::{Module, Post, PostExtension, FIRST_POST_ID, Config}; +pub type RepliesByPostId = BTreeMap>>; + +#[derive(Eq, PartialEq, Encode, Decode, Default)] +#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))] +#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))] +pub struct FlatPostExtension { + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] + pub is_regular_post: Option, + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] + pub is_shared_post: Option, + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] + pub is_comment: Option, + + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] + pub root_post_id: Option, + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] + pub parent_post_id: Option, + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] + pub shared_post_id: Option, +} + +impl From for FlatPostExtension { + fn from(from: PostExtension) -> Self { + let mut flat_ext = Self::default(); + + match from { + PostExtension::RegularPost => { + flat_ext.is_regular_post = Some(true); + } + PostExtension::Comment(comment_ext) => { + flat_ext.is_comment = Some(true); + flat_ext.root_post_id = Some(comment_ext.root_post_id); + flat_ext.parent_post_id = comment_ext.parent_id; + } + PostExtension::SharedPost(shared_post_id) => { + flat_ext.is_shared_post = Some(true); + flat_ext.shared_post_id = Some(shared_post_id); + } + } + + flat_ext + } +} + +#[derive(Eq, PartialEq, Encode, Decode, Default)] +#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))] +#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))] +pub struct FlatPost { + pub id: PostId, + + #[cfg_attr(feature = "std", serde(flatten))] + pub who_and_when: FlatWhoAndWhen, + + pub owner: AccountId, + + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] + pub space_id: Option, + + #[cfg_attr(feature = "std", serde(flatten))] + pub content: FlatContent, + + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] + pub is_hidden: Option, + + #[cfg_attr(feature = "std", serde(flatten))] + pub extension: FlatPostExtension, + + pub replies_count: u16, + pub hidden_replies_count: u16, + pub visible_replies_count: u16, + + pub shares_count: u16, + pub upvotes_count: u16, + pub downvotes_count: u16, +} + +#[derive(Encode, Decode, Ord, PartialOrd, Clone, Eq, PartialEq)] +#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] +pub enum FlatPostKind { + RegularPost, + Comment, + SharedPost +} + +impl From> for FlatPostKind { + fn from(from: Post) -> Self { + match from.extension { + PostExtension::RegularPost => { Self::RegularPost } + PostExtension::Comment(_) => { Self::Comment } + PostExtension::SharedPost(_) => { Self::SharedPost } + } + } +} + +impl From> for FlatPost { + fn from(from: Post) -> Self { + let Post { + id, created, updated, owner, + extension, space_id, content, hidden, replies_count, + hidden_replies_count, shares_count, upvotes_count, downvotes_count, .. + } = from; + + Self { + id, + who_and_when: (created, updated).into(), + owner, + space_id, + content: content.into(), + is_hidden: bool_to_option(hidden), + extension: extension.into(), + replies_count, + hidden_replies_count, + visible_replies_count: replies_count.saturating_sub(hidden_replies_count), + shares_count, + upvotes_count, + downvotes_count, + } + } +} + +impl Module { + fn get_posts_by_ids_with_filter) -> bool>( + all_post_ids: Vec, + offset: u64, + limit: u16, + mut filter: F, + ) -> Vec> { + let mut posts = Vec::new(); + + let (_, posts_ids) = all_post_ids.split_at(offset as usize); + + for post_id in posts_ids.iter() { + if let Ok(post) = Self::require_post(*post_id) { + if filter(&post) { + posts.push(post.into()); + } + } + + if posts.len() >= limit as usize { break; } + } + + posts + } + + pub fn get_posts_by_ids ( + post_ids: Vec, + offset: u64, + limit: u16, + ) -> Vec> { + Self::get_posts_by_ids_with_filter(post_ids, offset, limit, |_| true) + } + + pub fn get_public_posts_by_ids( + post_ids: Vec, + offset: u64, + limit: u16, + ) -> Vec> { + Self::get_posts_by_ids_with_filter(post_ids, offset, limit, |post| post.is_public()) + } + + fn get_posts_slice_by_space_id) -> bool>( + space_id: SpaceId, + offset: u64, + limit: u16, + filter: F, + ) -> Vec> { + let mut post_ids: Vec = Self::post_ids_by_space_id(space_id); + post_ids.reverse(); + + Self::get_posts_by_ids_with_filter(post_ids, offset, limit, filter) + } + + pub fn get_public_posts_by_space_id( + space_id: SpaceId, + offset: u64, + limit: u16, + ) -> Vec> { + if let Ok(space) = Spaces::::require_space(space_id) { + return Self::get_posts_slice_by_space_id(space.id, offset, limit, |post| post.is_public()); + } + + vec![] + } + + pub fn get_unlisted_posts_by_space_id( + space_id: SpaceId, + offset: u64, + limit: u16, + ) -> Vec> { + if let Ok(space) = Spaces::::require_space(space_id) { + return Self::get_posts_slice_by_space_id(space.id, offset, limit, |post| post.is_unlisted()); + } + + vec![] + } + + pub fn get_reply_ids_by_parent_id(parent_id: PostId) -> Vec { + Self::reply_ids_by_post_id(parent_id) + } + + pub fn get_replies_by_parent_id(parent_id: PostId, offset: u64, limit: u16) -> Vec> { + let reply_ids = Self::get_reply_ids_by_parent_id(parent_id); + Self::get_posts_by_ids(reply_ids, offset, limit) + } + + pub fn get_reply_ids_by_parent_ids(parent_ids: Vec) -> BTreeMap> { + let mut reply_ids_by_parent: BTreeMap> = BTreeMap::new(); + + for parent_id in parent_ids.iter() { + let reply_ids = Self::get_reply_ids_by_parent_id(*parent_id); + + if !reply_ids.is_empty() { + reply_ids_by_parent.insert(*parent_id, reply_ids); + } + } + + reply_ids_by_parent + } + + pub fn get_replies_by_parent_ids( + parent_ids: Vec, + offset: u64, + limit: u16 + ) -> RepliesByPostId { + + Self::get_reply_ids_by_parent_ids(parent_ids) + .into_iter() + .map(|(parent_id, reply_ids)| + (parent_id, Self::get_posts_by_ids(reply_ids, offset, limit)) + ) + .collect() + } + + pub fn get_public_posts( + kind_filter: Vec, + start_id: u64, + limit: u16, + ) -> Vec> { + + let no_filter = kind_filter.is_empty(); + let kind_filter_set: BTreeSet<_> = kind_filter.into_iter().collect(); + + let mut posts = Vec::new(); + let mut post_id = start_id; + + while posts.len() < limit as usize && post_id >= FIRST_POST_ID { + if let Ok(post) = Self::require_post(post_id) { + let kind: FlatPostKind = post.clone().into(); + + if post.is_public() && (no_filter || kind_filter_set.contains(&kind)) { + posts.push(post.into()); + } + } + post_id = post_id.saturating_sub(1); + } + + posts + } + + fn get_post_ids_by_space) -> bool>(space_id: SpaceId, mut filter: F) -> Vec { + Self::post_ids_by_space_id(space_id) + .iter() + .filter_map(Self::post_by_id) + .filter(|post| filter(post)) + .map(|post| post.id) + .collect() + } + + pub fn get_public_post_ids_by_space_id(space_id: SpaceId) -> Vec { + let public_space = Spaces::::require_space(space_id).ok().filter(|space| space.is_public()); + if public_space.is_some() { + return Self::get_post_ids_by_space(space_id, |post| post.is_public()); + } + + vec![] + } + + pub fn get_unlisted_post_ids_by_space_id(space_id: SpaceId) -> Vec { + let unlisted_space = Spaces::::require_space(space_id).ok().filter(|space| !space.is_public()); + if unlisted_space.is_some() { + return Self::get_post_ids_by_space(space_id, |post| !post.is_public()); + } + + vec![] + } + + pub fn get_next_post_id() -> PostId { + Self::next_post_id() + } + + pub fn get_feed(account: T::AccountId, offset: u64, limit: u16) -> Vec> { + let mut post_ids: Vec = SpaceFollows::::spaces_followed_by_account(account) + .iter() + .flat_map(Self::post_ids_by_space_id) + .collect(); + + // Sort post ids in a descending order + post_ids.sort_by(|a, b| b.cmp(a)); + + Self::get_posts_by_ids_with_filter(post_ids, offset, limit, |post| post.is_public() && !post.is_comment()) + } +} diff --git a/pallets/posts/src/types.rs b/pallets/posts/src/types.rs new file mode 100644 index 0000000..ff0ab21 --- /dev/null +++ b/pallets/posts/src/types.rs @@ -0,0 +1,71 @@ +use super::*; + +pub const FIRST_POST_ID: u64 = 1; + +/// Information about a post's owner, its' related space, content, and visibility. +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +#[scale_info(skip_type_params(T))] +pub struct Post { + /// Unique sequential identifier of a post. Examples of post ids: `1`, `2`, `3`, and so on. + pub id: PostId, + + pub created: WhoAndWhenOf, + /// True, if the content of this post was edited. + pub edited: bool, + + /// The current owner of a given post. + pub owner: T::AccountId, + + /// Through post extension you can provide specific information necessary for different kinds + /// of posts such as regular posts, comments, and shared posts. + pub extension: PostExtension, + + /// An id of a space which contains a given post. + pub space_id: Option, + + pub content: Content, + + /// Hidden field is used to recommend to end clients (web and mobile apps) that a particular + /// posts and its' comments should not be shown. + pub hidden: bool, + + /// The number of times a given post has been upvoted. + pub upvotes_count: u32, + + /// The number of times a given post has been downvoted. + pub downvotes_count: u32, +} + +#[derive(Encode, Decode, Default, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +pub struct PostUpdate { + /// Deprecated: This field has no effect in `fn update_post()` extrinsic. + /// See `fn move_post()` extrinsic if you want to move a post to another space. + pub space_id: Option, + + pub content: Option, + pub hidden: Option, +} + +/// Post extension provides specific information necessary for different kinds +/// of posts such as regular posts, comments, and shared posts. +#[derive(Encode, Decode, Clone, Copy, Eq, PartialEq, RuntimeDebug, TypeInfo)] +#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] +#[cfg_attr(feature = "std", serde(untagged))] +pub enum PostExtension { + RegularPost, + Comment(Comment), + SharedPost(PostId), +} + +#[derive(Encode, Decode, Clone, Copy, Eq, PartialEq, RuntimeDebug, TypeInfo)] +#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] +pub struct Comment { + pub root_post_id: PostId, + pub parent_id: Option, +} + +impl Default for PostExtension { + fn default() -> Self { + PostExtension::RegularPost + } +} diff --git a/pallets/posts/src/weights.rs b/pallets/posts/src/weights.rs new file mode 100644 index 0000000..e756f9a --- /dev/null +++ b/pallets/posts/src/weights.rs @@ -0,0 +1,169 @@ + +//! Autogenerated weights for pallet_posts +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-02-14, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 + +// Executed Command: + // ./scripts/../target/release/subsocial-collator + // benchmark + // pallet + // --chain + // dev + // --execution + // wasm + // --wasm-execution + // Compiled + // --pallet + // pallet_posts + // --extrinsic + // * + // --steps + // 50 + // --repeat + // 20 + // --heap-pages + // 4096 + // --output + // pallets/posts/src/weights.rs + // --template + // ./.maintain/weight-template.hbs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(non_snake_case)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weight functions needed for pallet_posts. +pub trait WeightInfo { + fn create_post__regular() -> Weight; + fn create_post__shared() -> Weight; + fn create_post__comment() -> Weight; + fn update_post() -> Weight; + fn move_post() -> Weight; +} + +/// Weights for pallet_posts using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); + impl WeightInfo for SubstrateWeight { + // Storage: Posts NextPostId (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) + // Storage: Posts PostIdsBySpaceId (r:1 w:1) + // Storage: Posts PostById (r:0 w:1) + fn create_post__regular() -> Weight { + // Minimum execution time: 30_000 nanoseconds. + Weight::from_ref_time(47_502_000) + .saturating_add(T::DbWeight::get().reads(5)) + .saturating_add(T::DbWeight::get().writes(3)) + } + // Storage: Posts NextPostId (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) + // Storage: Posts PostById (r:1 w:1) + // Storage: Posts SharedPostIdsByOriginalPostId (r:1 w:1) + // Storage: Posts PostIdsBySpaceId (r:1 w:1) + fn create_post__shared() -> Weight { + // Minimum execution time: 39_000 nanoseconds. + Weight::from_ref_time(62_353_000) + .saturating_add(T::DbWeight::get().reads(7)) + .saturating_add(T::DbWeight::get().writes(4)) + } + // Storage: Posts NextPostId (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Posts PostById (r:2 w:1) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) + // Storage: Posts ReplyIdsByPostId (r:1 w:1) + fn create_post__comment() -> Weight { + // Minimum execution time: 39_000 nanoseconds. + Weight::from_ref_time(59_771_000) + .saturating_add(T::DbWeight::get().reads(7)) + .saturating_add(T::DbWeight::get().writes(3)) + } + // Storage: Posts PostById (r:2 w:1) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) + fn update_post() -> Weight { + // Minimum execution time: 30_000 nanoseconds. + Weight::from_ref_time(48_472_000) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(1)) + } + // Storage: Posts PostById (r:1 w:1) + // Storage: Spaces SpaceById (r:2 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:2 w:0) + // Storage: Posts PostIdsBySpaceId (r:2 w:2) + fn move_post() -> Weight { + // Minimum execution time: 39_000 nanoseconds. + Weight::from_ref_time(60_733_000) + .saturating_add(T::DbWeight::get().reads(7)) + .saturating_add(T::DbWeight::get().writes(3)) + } + } + + // For backwards compatibility and tests + impl WeightInfo for () { + // Storage: Posts NextPostId (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) + // Storage: Posts PostIdsBySpaceId (r:1 w:1) + // Storage: Posts PostById (r:0 w:1) + fn create_post__regular() -> Weight { + // Minimum execution time: 30_000 nanoseconds. + Weight::from_ref_time(47_502_000) + .saturating_add(RocksDbWeight::get().reads(5)) + .saturating_add(RocksDbWeight::get().writes(3)) + } + // Storage: Posts NextPostId (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) + // Storage: Posts PostById (r:1 w:1) + // Storage: Posts SharedPostIdsByOriginalPostId (r:1 w:1) + // Storage: Posts PostIdsBySpaceId (r:1 w:1) + fn create_post__shared() -> Weight { + // Minimum execution time: 39_000 nanoseconds. + Weight::from_ref_time(62_353_000) + .saturating_add(RocksDbWeight::get().reads(7)) + .saturating_add(RocksDbWeight::get().writes(4)) + } + // Storage: Posts NextPostId (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Posts PostById (r:2 w:1) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) + // Storage: Posts ReplyIdsByPostId (r:1 w:1) + fn create_post__comment() -> Weight { + // Minimum execution time: 39_000 nanoseconds. + Weight::from_ref_time(59_771_000) + .saturating_add(RocksDbWeight::get().reads(7)) + .saturating_add(RocksDbWeight::get().writes(3)) + } + // Storage: Posts PostById (r:2 w:1) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) + fn update_post() -> Weight { + // Minimum execution time: 30_000 nanoseconds. + Weight::from_ref_time(48_472_000) + .saturating_add(RocksDbWeight::get().reads(4)) + .saturating_add(RocksDbWeight::get().writes(1)) + } + // Storage: Posts PostById (r:1 w:1) + // Storage: Spaces SpaceById (r:2 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:2 w:0) + // Storage: Posts PostIdsBySpaceId (r:2 w:2) + fn move_post() -> Weight { + // Minimum execution time: 39_000 nanoseconds. + Weight::from_ref_time(60_733_000) + .saturating_add(RocksDbWeight::get().reads(7)) + .saturating_add(RocksDbWeight::get().writes(3)) + } + } diff --git a/pallets/posts/tests/Cargo.toml b/pallets/posts/tests/Cargo.toml new file mode 100644 index 0000000..8c20489 --- /dev/null +++ b/pallets/posts/tests/Cargo.toml @@ -0,0 +1,60 @@ +[package] +name = 'pallet-posts-tests' +version = '0.1.7' +authors = ['DappForce '] +edition = '2021' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Posts pallet tests' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } + +# Local dependencies +subsocial-support = { default-features = false, path = '../../support' } +pallet-permissions = { default-features = false, path = '../../permissions' } + +# Substrate dependencies +pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } + +[dev-dependencies] +sp-core = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-io = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } +pallet-roles = { default-features = false, path = '../../roles' } +pallet-space-follows = { default-features = false, path = '../../space-follows' } +pallet-space-ownership = { default-features = false, path = '../../space-ownership' } +pallet-profiles = { default-features = false, path = '../../profiles' } +pallet-posts = { default-features = false, path = '..' } +pallet-spaces = { default-features = false, path = '../../spaces' } + +[features] +default = ['std'] +std = [ + 'codec/std', + 'scale-info/std', + 'pallet-timestamp/std', + 'frame-support/std', + 'frame-system/std', + 'sp-runtime/std', + 'sp-std/std', + 'pallet-permissions/std', + 'pallet-balances/std', + 'pallet-roles/std', + 'pallet-space-follows/std', + 'pallet-space-ownership/std', + 'pallet-profiles/std', + 'pallet-posts/std', +] +try-runtime = ["frame-support/try-runtime"] diff --git a/pallets/posts/tests/src/comments_tests.rs b/pallets/posts/tests/src/comments_tests.rs new file mode 100644 index 0000000..265d8a1 --- /dev/null +++ b/pallets/posts/tests/src/comments_tests.rs @@ -0,0 +1,209 @@ +use frame_support::{assert_noop, assert_ok}; +use sp_runtime::DispatchError; + +use pallet_posts::Error as PostsError; +use subsocial_support::{mock_functions::*, ContentError, PostId}; + +use crate::{mock::*, tests_utils::*}; + +#[test] +fn create_comment_should_work() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_create_default_comment()); // PostId 2 by ACCOUNT1 which is permitted by default + + // Check storages + assert_eq!(Posts::reply_ids_by_post_id(POST1), vec![POST2]); + + // Check whether data stored correctly + let comment = Posts::post_by_id(POST2).unwrap(); + let comment_ext = comment.get_comment_ext().unwrap(); + + assert!(comment_ext.parent_id.is_none()); + assert_eq!(comment_ext.root_post_id, POST1); + assert_eq!(comment.created.account, ACCOUNT1); + assert!(!comment.edited); + assert_eq!(comment.content, comment_content_ipfs()); + + assert_eq!(comment.upvotes_count, 0); + assert_eq!(comment.downvotes_count, 0); + }); +} + +#[test] +fn create_comment_should_work_when_comment_has_parents() { + ExtBuilder::build_with_comment().execute_with(|| { + let first_comment_id = 2; + let last_comment_id = first_comment_id + (MaxCommentDepth::get() as PostId) - 1; + + // Create + for parent_id in first_comment_id..last_comment_id { + assert_ok!(_create_comment(None, None, Some(Some(parent_id)), None)); + } + + let parent_id = last_comment_id - 1; + let parent_id_by_one = parent_id - 1; + + // We should check that counters were increased by 1 for all ancestor comments + // except the last parent. + for comment_id in first_comment_id..parent_id_by_one { + // All of comments has 1 reply as they respond to each other. + assert_eq!(Posts::reply_ids_by_post_id(comment_id), vec![comment_id + 1]); + } + + assert_eq!(Posts::reply_ids_by_post_id(parent_id), vec![last_comment_id]); + + assert!(Posts::reply_ids_by_post_id(last_comment_id).is_empty()); + }); +} + +#[test] +fn create_comment_should_fail_when_post_not_found() { + ExtBuilder::build().execute_with(|| { + // Try to catch an error creating a comment with wrong post + assert_noop!(_create_default_comment(), PostsError::::PostNotFound); + }); +} + +#[test] +fn create_comment_should_fail_when_parent_comment_is_unknown() { + ExtBuilder::build_with_post().execute_with(|| { + // Try to catch an error creating a comment with wrong parent + assert_noop!( + _create_comment(None, None, Some(Some(POST2)), None), + PostsError::::UnknownParentComment + ); + }); +} + +#[test] +fn create_comment_should_fail_when_ipfs_cid_is_invalid() { + ExtBuilder::build_with_post().execute_with(|| { + // Try to catch an error creating a comment with wrong parent + assert_noop!( + _create_comment(None, None, None, Some(invalid_content_ipfs())), + DispatchError::from(ContentError::InvalidIpfsCid) + ); + }); +} + +#[test] +fn create_comment_should_fail_when_trying_to_create_in_hidden_space_scope() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_update_space(None, None, Some(space_update(None, Some(true))))); + + assert_noop!(_create_default_comment(), PostsError::::CannotCreateInHiddenScope); + }); +} + +#[test] +fn create_comment_should_fail_when_trying_create_in_hidden_post_scope() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_update_post(None, None, Some(post_update(None, None, Some(true))))); + + assert_noop!(_create_default_comment(), PostsError::::CannotCreateInHiddenScope); + }); +} + +#[test] +fn create_comment_should_fail_when_max_comment_depth_reached() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_create_comment(None, None, Some(None), None)); // PostId 2 + + for parent_id in 2..11_u64 { + assert_ok!(_create_comment(None, None, Some(Some(parent_id)), None)); + // PostId N (last = 10) + } + + // Some(Some(11)) - here is parent_id 11 of type PostId + assert_noop!( + _create_comment(None, None, Some(Some(11)), None), + PostsError::::MaxCommentDepthReached + ); + }); +} + +#[test] +fn update_comment_should_work() { + ExtBuilder::build_with_comment().execute_with(|| { + // Post update with ID 1 should be fine + assert_ok!(_update_comment(None, None, None)); + + // Check whether post updates correctly + let comment = Posts::post_by_id(POST2).unwrap(); + assert_eq!(comment.content, reply_content_ipfs()); + }); +} + +#[test] +fn update_comment_hidden_should_work_when_comment_has_parents() { + ExtBuilder::build_with_comment().execute_with(|| { + let first_comment_id = 2; + let last_comment_id = first_comment_id + (MaxCommentDepth::get() as PostId) - 1; + + // Create comments from 3 to 11 + for parent_id in first_comment_id..last_comment_id { + assert_ok!(_create_comment(None, None, Some(Some(parent_id)), None)); + } + + let should_hide_id = last_comment_id - 3; + let should_hide_by_one_id = should_hide_id - 1; + + assert_ok!(_update_comment( + None, + Some(should_hide_id), + Some(post_update( + None, + None, + Some(true) // make comment hidden + )) + )); + + // We should check that counters weren't increased for all ancestor comments + // except the last before hidden. + for comment_id in first_comment_id..should_hide_by_one_id { + // All of comments has 1 replies as they reply to each other. + assert_eq!(Posts::reply_ids_by_post_id(comment_id), vec![comment_id + 1]); + } + + assert_eq!( + Posts::reply_ids_by_post_id(should_hide_by_one_id), + vec![should_hide_by_one_id + 1] + ); + assert_eq!(Posts::reply_ids_by_post_id(should_hide_id), vec![should_hide_id + 1]); + }); +} + +#[test] +// `PostNotFound` here: Post with Comment extension. Means that comment wasn't found. +fn update_comment_should_fail_when_post_not_found() { + ExtBuilder::build().execute_with(|| { + // Try to catch an error updating a comment with wrong PostId + assert_noop!(_update_comment(None, None, None), PostsError::::PostNotFound); + }); +} + +#[test] +fn update_comment_should_fail_when_account_is_not_a_comment_author() { + ExtBuilder::build_with_comment().execute_with(|| { + // Try to catch an error updating a comment with wrong Account + assert_noop!( + _update_comment(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None), + PostsError::::NotACommentAuthor + ); + }); +} + +#[test] +fn update_comment_should_fail_when_ipfs_cid_is_invalid() { + ExtBuilder::build_with_comment().execute_with(|| { + // Try to catch an error updating a comment with invalid content + assert_noop!( + _update_comment( + None, + None, + Some(post_update(None, Some(invalid_content_ipfs()), None)) + ), + DispatchError::from(ContentError::InvalidIpfsCid) + ); + }); +} diff --git a/pallets/posts/tests/src/lib.rs b/pallets/posts/tests/src/lib.rs new file mode 100644 index 0000000..d2fbb87 --- /dev/null +++ b/pallets/posts/tests/src/lib.rs @@ -0,0 +1,10 @@ +#[cfg(test)] +mod comments_tests; +#[cfg(test)] +mod mock; +#[cfg(test)] +mod post_tests; +#[cfg(test)] +mod shared_posts_tests; +#[cfg(test)] +mod tests_utils; diff --git a/pallets/posts/tests/src/mock.rs b/pallets/posts/tests/src/mock.rs new file mode 100644 index 0000000..da6192a --- /dev/null +++ b/pallets/posts/tests/src/mock.rs @@ -0,0 +1,151 @@ +use frame_support::{pallet_prelude::ConstU32, parameter_types, traits::Everything}; +use sp_core::H256; +use sp_runtime::{ + testing::Header, + traits::{BlakeTwo256, IdentityLookup}, +}; +use sp_std::convert::{TryFrom, TryInto}; + +use crate::tests_utils::*; + +type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; +type Block = frame_system::mocking::MockBlock; + +frame_support::construct_runtime!( + pub enum Test where + Block = Block, + NodeBlock = Block, + UncheckedExtrinsic = UncheckedExtrinsic, + { + System: frame_system, + Timestamp: pallet_timestamp, + Balances: pallet_balances, + Permissions: pallet_permissions, + Roles: pallet_roles, + Profiles: pallet_profiles, + SpaceFollows: pallet_space_follows, + Posts: pallet_posts, + Spaces: pallet_spaces, + SpaceOwnership: pallet_space_ownership, + } +); + +pub(super) type AccountId = u64; +pub(super) type Balance = u64; +pub(super) type BlockNumber = u64; + +parameter_types! { + pub const BlockHashCount: u64 = 250; + pub const SS58Prefix: u8 = 42; +} + +impl frame_system::Config for Test { + type BaseCallFilter = Everything; + type BlockWeights = (); + type BlockLength = (); + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + type Index = u64; + type BlockNumber = BlockNumber; + type Hash = H256; + type Hashing = BlakeTwo256; + type AccountId = AccountId; + type Lookup = IdentityLookup; + type Header = Header; + type RuntimeEvent = RuntimeEvent; + type BlockHashCount = BlockHashCount; + type DbWeight = (); + type Version = (); + type PalletInfo = PalletInfo; + type AccountData = pallet_balances::AccountData; + type OnNewAccount = (); + type OnKilledAccount = (); + type SystemWeightInfo = (); + type SS58Prefix = SS58Prefix; + type OnSetCode = (); + type MaxConsumers = frame_support::traits::ConstU32<16>; +} + +parameter_types! { + pub const MinimumPeriod: u64 = 5; +} + +impl pallet_timestamp::Config for Test { + type Moment = u64; + type OnTimestampSet = (); + type MinimumPeriod = MinimumPeriod; + type WeightInfo = (); +} + +parameter_types! { + pub const ExistentialDeposit: u64 = 1; +} + +impl pallet_balances::Config for Test { + type Balance = Balance; + type DustRemoval = (); + type RuntimeEvent = RuntimeEvent; + type ExistentialDeposit = ExistentialDeposit; + type AccountStore = System; + type WeightInfo = (); + type MaxLocks = (); + type MaxReserves = (); + type ReserveIdentifier = (); +} + +parameter_types! { + pub const MaxCommentDepth: u32 = 10; +} + +impl pallet_posts::Config for Test { + type RuntimeEvent = RuntimeEvent; + type MaxCommentDepth = MaxCommentDepth; + type IsPostBlocked = MockModeration; + type WeightInfo = (); +} + +impl pallet_permissions::Config for Test { + type DefaultSpacePermissions = pallet_permissions::default_permissions::DefaultSpacePermissions; +} + +parameter_types! { + pub const MaxUsersToProcessPerDeleteRole: u16 = 40; +} + +impl pallet_roles::Config for Test { + type RuntimeEvent = RuntimeEvent; + type MaxUsersToProcessPerDeleteRole = MaxUsersToProcessPerDeleteRole; + type SpacePermissionsProvider = Spaces; + type SpaceFollows = SpaceFollows; + type IsAccountBlocked = MockModeration; + type IsContentBlocked = MockModeration; + type WeightInfo = (); +} + +impl pallet_profiles::Config for Test { + type RuntimeEvent = RuntimeEvent; + type SpacePermissionsProvider = Spaces; + type SpacesInterface = Spaces; + type WeightInfo = (); +} + +impl pallet_spaces::Config for Test { + type RuntimeEvent = RuntimeEvent; + type Roles = Roles; + type SpaceFollows = SpaceFollows; + type IsAccountBlocked = MockModeration; + type IsContentBlocked = MockModeration; + type MaxSpacesPerAccount = ConstU32<100>; + type WeightInfo = (); +} + +impl pallet_space_follows::Config for Test { + type RuntimeEvent = RuntimeEvent; + type WeightInfo = (); +} + +impl pallet_space_ownership::Config for Test { + type RuntimeEvent = RuntimeEvent; + type ProfileManager = Profiles; + type WeightInfo = (); +} diff --git a/pallets/posts/tests/src/post_tests.rs b/pallets/posts/tests/src/post_tests.rs new file mode 100644 index 0000000..973c98b --- /dev/null +++ b/pallets/posts/tests/src/post_tests.rs @@ -0,0 +1,612 @@ +use frame_support::{assert_noop, assert_ok}; +use sp_runtime::DispatchError; + +use pallet_permissions::SpacePermission as SP; +use pallet_posts::{Error as PostsError, Post}; +use pallet_spaces::Error as SpacesError; +use subsocial_support::{mock_functions::*, ContentError, ModerationError, PostId, SpaceId}; + +use crate::{mock::*, tests_utils::*}; + +#[test] +fn create_post_should_fail_when_content_is_blocked() { + ExtBuilder::build_with_post().execute_with(|| { + block_content_in_space_1(); + assert_noop!( + _create_post(None, None, None, Some(valid_content_ipfs()),), + DispatchError::Other(ModerationError::ContentIsBlocked.into()), + ); + }); +} + +#[test] +fn create_post_should_fail_when_account_is_blocked() { + ExtBuilder::build_with_post().execute_with(|| { + block_account_in_space_1(); + assert_noop!( + _create_post(None, None, None, Some(valid_content_ipfs()),), + DispatchError::Other(ModerationError::AccountIsBlocked.into()), + ); + }); +} + +#[test] +fn update_post_should_fail_when_content_is_blocked() { + ExtBuilder::build_with_post().execute_with(|| { + block_content_in_space_1(); + assert_noop!( + _update_post( + None, // From ACCOUNT1 (has default permission to UpdateOwnPosts) + None, + Some(post_update(None, Some(valid_content_ipfs()), Some(true))) + ), + DispatchError::Other(ModerationError::ContentIsBlocked.into()) + ); + }); +} + +#[test] +fn update_post_should_fail_when_account_is_blocked() { + ExtBuilder::build_with_post().execute_with(|| { + block_account_in_space_1(); + assert_noop!( + _update_post( + None, // From ACCOUNT1 (has default permission to UpdateOwnPosts) + None, + Some(post_update(None, Some(valid_content_ipfs()), Some(true))) + ), + DispatchError::Other(ModerationError::AccountIsBlocked.into()) + ); + }); +} + +// FIXME: uncomment when `update_post` will be able to move post from one space to another +/* +#[test] +fn update_post_should_fail_when_post_is_blocked() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!( + _update_entity_status( + None, + Some(EntityId::Post(POST1)), + Some(SPACE1), + Some(Some(EntityStatus::Blocked)) + ) + ); + assert_noop!( + _update_post( + None, // From ACCOUNT1 (has default permission to UpdateOwnPosts) + Some(POST1), + Some( + post_update( + Some(SPACE1), + None, + None + ) + ) + ), ModerationError::PostIsBlocked.into() + ); + }); +} +*/ + +#[test] +fn create_post_should_work() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!(_create_default_post()); // PostId 1 by ACCOUNT1 which is permitted by default + + // Check storages + assert_eq!(Posts::post_ids_by_space_id(SPACE1), vec![POST1]); + assert_eq!(Posts::next_post_id(), POST2); + + // Check whether data stored correctly + let post = Posts::post_by_id(POST1).unwrap(); + + assert_eq!(post.created.account, ACCOUNT1); + assert!(!post.edited); + assert!(!post.hidden); + + assert_eq!(post.space_id, Some(SPACE1)); + assert_eq!(post.extension, extension_regular_post()); + + assert_eq!(post.content, post_content_ipfs()); + + assert_eq!(post.upvotes_count, 0); + assert_eq!(post.downvotes_count, 0); + }); +} + +#[test] +fn create_post_should_work_when_one_of_roles_is_permitted() { + ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::CreatePosts]).execute_with( + || { + assert_ok!(_create_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // SpaceId 1, + None, // RegularPost extension + None, // Default post content + )); + }, + ); +} + +#[test] +fn create_post_should_fail_when_post_has_no_space_id() { + ExtBuilder::build_with_space().execute_with(|| { + assert_noop!( + _create_post(None, Some(None), None, None), + PostsError::::PostHasNoSpaceId + ); + }); +} + +#[test] +fn create_post_should_fail_when_space_not_found() { + ExtBuilder::build().execute_with(|| { + assert_noop!(_create_default_post(), SpacesError::::SpaceNotFound); + }); +} + +#[test] +fn create_post_should_fail_when_ipfs_cid_is_invalid() { + ExtBuilder::build_with_space().execute_with(|| { + // Try to catch an error creating a regular post with invalid content + assert_noop!( + _create_post(None, None, None, Some(invalid_content_ipfs())), + DispatchError::from(ContentError::InvalidIpfsCid) + ); + }); +} + +#[test] +fn create_post_should_fail_when_account_has_no_permission() { + ExtBuilder::build_with_space().execute_with(|| { + assert_noop!( + _create_post(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None, None), + PostsError::::NoPermissionToCreatePosts + ); + }); +} + +#[test] +fn create_post_should_fail_when_no_right_permission_in_account_roles() { + ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::CreatePosts]).execute_with( + || { + assert_ok!(_delete_default_role()); + + assert_noop!( + _create_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // SpaceId 1, + None, // RegularPost extension + None, // Default post content + ), + PostsError::::NoPermissionToCreatePosts + ); + }, + ); +} + +#[test] +fn update_post_should_work() { + ExtBuilder::build_with_post().execute_with(|| { + let expected_content_ipfs = updated_post_content(); + + // Post update with ID 1 should be fine + assert_ok!(_update_post( + None, // From ACCOUNT1 (has default permission to UpdateOwnPosts) + None, + Some(post_update(None, Some(expected_content_ipfs.clone()), Some(true))) + )); + + // Check whether post updates correctly + let post = Posts::post_by_id(POST1).unwrap(); + assert_eq!(post.space_id, Some(SPACE1)); + assert_eq!(post.content, expected_content_ipfs); + assert!(post.hidden); + }); +} + +fn check_if_post_moved_correctly(moved_post_id: PostId, expected_new_space_id: SpaceId) { + let post: Post = Posts::post_by_id(moved_post_id).unwrap(); // `POST2` is a comment + let new_space_id = post.space_id.unwrap(); + + // Check that space id of the post has been updated from 1 to 2 + assert_eq!(new_space_id, expected_new_space_id); +} + +#[test] +fn move_post_should_work() { + ExtBuilder::build_with_post_and_two_spaces().execute_with(|| { + assert_ok!(_move_post_1_to_space_2()); + + let moved_post_id = POST1; + let old_space_id = SPACE1; + let expected_new_space_id = SPACE2; + check_if_post_moved_correctly(moved_post_id, expected_new_space_id); + + // Check that there are no posts ids in the old space + assert!(Posts::post_ids_by_space_id(old_space_id).is_empty()); + + // Check that there is the post id in the new space + assert_eq!(Posts::post_ids_by_space_id(expected_new_space_id), vec![moved_post_id]); + }); +} + +#[test] +fn move_post_should_work_when_space_id_none() { + ExtBuilder::build_with_post_and_two_spaces().execute_with(|| { + let moved_post_id = POST1; + let old_space_id = SPACE1; // Where post were before moving to `SpaceId:None` + let expected_new_space_id = SPACE2; + + assert_ok!(_move_post_to_nowhere(moved_post_id)); + assert_ok!(_move_post_1_to_space_2()); + + check_if_post_moved_correctly(moved_post_id, expected_new_space_id); + + // Check that there are no posts ids in the old space + assert!(Posts::post_ids_by_space_id(old_space_id).is_empty()); + + // Check that there is the post id in the new space + assert_eq!(Posts::post_ids_by_space_id(expected_new_space_id), vec![moved_post_id]); + }); +} + +#[test] +fn move_hidden_post_should_work() { + ExtBuilder::build_with_post_and_two_spaces().execute_with(|| { + let moved_post_id = POST1; + let old_space_id = SPACE1; + let expected_new_space_id = SPACE2; + + // Hide the post before moving it + assert_ok!(_update_post( + None, + Some(moved_post_id), + Some(post_update(None, None, Some(true))) + )); + + assert_ok!(_move_post_1_to_space_2()); + + check_if_post_moved_correctly(moved_post_id, expected_new_space_id); + + // Check that there are no posts ids in the old space + assert!(Posts::post_ids_by_space_id(old_space_id).is_empty()); + + // Check that there is the post id in the new space + assert_eq!(Posts::post_ids_by_space_id(expected_new_space_id), vec![moved_post_id]); + }); +} + +#[test] +fn move_hidden_post_should_fail_when_post_not_found() { + ExtBuilder::build().execute_with(|| { + // Note that we have not created a post that we are trying to move + assert_noop!(_move_post_1_to_space_2(), PostsError::::PostNotFound); + }); +} + +#[test] +fn move_hidden_post_should_fail_when_provided_space_not_found() { + ExtBuilder::build_with_post().execute_with(|| { + // Note that we have not created a new space #2 before moving the post + assert_noop!(_move_post_1_to_space_2(), SpacesError::::SpaceNotFound); + }); +} + +#[test] +fn move_hidden_post_should_fail_origin_has_no_permission_to_create_posts() { + ExtBuilder::build_with_post().execute_with(|| { + // Create a space #2 from account #2 + assert_ok!(_create_space(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None)); + + // Should not be possible to move the post b/c it's owner is account #1 + // when the space #2 is owned by account #2 + assert_noop!(_move_post_1_to_space_2(), PostsError::::NoPermissionToCreatePosts); + }); +} + +#[test] +fn move_post_should_fail_when_account_has_no_permission() { + ExtBuilder::build_with_post_and_two_spaces().execute_with(|| { + assert_noop!( + _move_post(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None), + PostsError::::NoPermissionToUpdateAnyPost + ); + }); +} + +#[test] +fn move_post_should_fail_when_space_none_and_account_is_not_post_owner() { + ExtBuilder::build_with_post_and_two_spaces().execute_with(|| { + assert_ok!(_move_post_to_nowhere(POST1)); + assert_noop!( + _move_post(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None), + PostsError::::NotAPostOwner + ); + }); +} + +#[test] +fn should_fail_when_trying_to_move_comment() { + ExtBuilder::build_with_comment().execute_with(|| { + assert_ok!(_create_space(None, None, None)); + + // Comments cannot be moved, they stick to their parent post + assert_noop!( + _move_post(None, Some(POST2), None), + PostsError::::CannotUpdateSpaceIdOnComment + ); + }); +} + +#[test] +fn update_post_should_work_after_transfer_space_ownership() { + ExtBuilder::build_with_post().execute_with(|| { + let post_update = post_update(None, Some(updated_post_content()), Some(true)); + + assert_ok!(_transfer_default_space_ownership()); + + // Post update with ID 1 should be fine + assert_ok!(_update_post(None, None, Some(post_update))); + }); +} + +#[test] +fn update_any_post_should_work_when_account_has_default_permission() { + ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::CreatePosts]).execute_with( + || { + let post_update = post_update(None, Some(updated_post_content()), Some(true)); + assert_ok!(_create_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // SpaceId 1 + None, // RegularPost extension + None // Default post content + )); // PostId 1 + + // Post update with ID 1 should be fine + assert_ok!(_update_post( + None, // From ACCOUNT1 (has default permission to UpdateAnyPosts as SpaceOwner) + Some(POST1), + Some(post_update) + )); + }, + ); +} + +#[test] +fn update_any_post_should_work_when_one_of_roles_is_permitted() { + ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::UpdateAnyPost]).execute_with( + || { + let post_update = post_update(None, Some(updated_post_content()), Some(true)); + assert_ok!(_create_default_post()); // PostId 1 + + // Post update with ID 1 should be fine + assert_ok!(_update_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + Some(POST1), + Some(post_update) + )); + }, + ); +} + +#[test] +fn update_post_should_fail_when_no_updates_for_post_provided() { + ExtBuilder::build_with_post().execute_with(|| { + // Try to catch an error updating a post with no changes + assert_noop!(_update_post(None, None, None), PostsError::::NoUpdatesForPost); + }); +} + +#[test] +fn update_post_should_fail_when_post_not_found() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_create_space(None, None, None)); // SpaceId 2 + + // Try to catch an error updating a post with wrong post ID + assert_noop!( + _update_post( + None, + Some(POST2), + Some(post_update( + // FIXME: when Post's `space_id` update is fully implemented + None, /* Some(SPACE2) */ + None, + Some(true) /* None */ + )) + ), + PostsError::::PostNotFound + ); + }); +} + +#[test] +fn update_post_should_fail_when_account_has_no_permission_to_update_any_post() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_create_space(None, None, None)); // SpaceId 2 + + // Try to catch an error updating a post with different account + assert_noop!( + _update_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, + Some(post_update( + // FIXME: when Post's `space_id` update is fully implemented + None, /* Some(SPACE2) */ + None, + Some(true) /* None */ + )) + ), + PostsError::::NoPermissionToUpdateAnyPost + ); + }); +} + +#[test] +fn update_post_should_fail_when_ipfs_cid_is_invalid() { + ExtBuilder::build_with_post().execute_with(|| { + // Try to catch an error updating a post with invalid content + assert_noop!( + _update_post(None, None, Some(post_update(None, Some(invalid_content_ipfs()), None))), + DispatchError::from(ContentError::InvalidIpfsCid) + ); + }); +} + +#[test] +fn update_post_should_fail_when_no_right_permission_in_account_roles() { + ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::UpdateAnyPost]).execute_with( + || { + let post_update = post_update(None, Some(updated_post_content()), Some(true)); + assert_ok!(_create_default_post()); + // PostId 1 + assert_ok!(_delete_default_role()); + + // Post update with ID 1 should be fine + assert_noop!( + _update_post(Some(RuntimeOrigin::signed(ACCOUNT2)), Some(POST1), Some(post_update)), + PostsError::::NoPermissionToUpdateAnyPost + ); + }, + ); +} + +// TODO: refactor or remove. Deprecated tests +// Find public post ids tests +// -------------------------------------------------------------------------------------------- +/*#[test] +fn find_public_post_ids_in_space_should_work() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_create_post(None, Some(Some(SPACE1)), None, None)); + + let post_ids = Posts::find_public_post_ids_in_space(SPACE1, 0, 3); + assert_eq!(post_ids, vec![POST1, POST2]); + }); +} + +#[test] +fn find_public_post_ids_in_space_should_work_with_zero_offset() { + ExtBuilder::build_with_post().execute_with(|| { + let post_ids = Posts::find_public_post_ids_in_space(SPACE1, 0, 1); + assert_eq!(post_ids, vec![POST1]); + }); +} + +#[test] +fn find_public_post_ids_in_space_should_work_with_zero_limit() { + ExtBuilder::build_with_post().execute_with(|| { + let post_ids = Posts::find_public_post_ids_in_space(SPACE1, 1, 0); + assert_eq!(post_ids, vec![POST1]); + }); +} + +#[test] +fn find_public_post_ids_in_space_should_work_with_zero_offset_and_zero_limit() { + ExtBuilder::build_with_post().execute_with(|| { + let post_ids = Posts::find_public_post_ids_in_space(SPACE1, 0, 0); + assert_eq!(post_ids, vec![]); + }); +} + +// Find unlisted post ids tests +// -------------------------------------------------------------------------------------------- + +#[test] +fn find_unlisted_post_ids_in_space_should_work() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_create_post(None, Some(Some(SPACE1)), None, None)); + assert_ok!( + _update_post( + None, + None, + Some( + post_update( + None, + Some(Content::None), + Some(true)) + ) + ) + ); + assert_ok!( + _update_post( + None, + Some(POST2), + Some( + post_update( + None, + Some(Content::None), + Some(true)) + ) + ) + ); + + let post_ids = Posts::find_unlisted_post_ids_in_space(SPACE1, 0, 3); + assert_eq!(post_ids, vec![POST1, POST2]); + }); +} + +#[test] +fn find_unlisted_post_ids_in_space_should_work_with_zero_offset() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!( + _update_post( + None, + None, + Some( + post_update( + None, + Some(Content::None), + Some(true)) + ) + ) + ); + + let post_ids = Posts::find_unlisted_post_ids_in_space(SPACE1, 0, 1); + assert_eq!(post_ids, vec![POST1]); + }); +} + +#[test] +fn find_unlisted_post_ids_in_space_should_work_with_zero_limit() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!( + _update_post( + None, + None, + Some( + post_update( + None, + Some(Content::None), + Some(true)) + ) + ) + ); + + let post_ids = Posts::find_unlisted_post_ids_in_space(SPACE1, 1, 0); + assert_eq!(post_ids, vec![POST1]); + }); +} + +#[test] +fn find_unlisted_post_ids_in_space_should_work_with_zero_offset_and_zero_limit() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!( + _update_post( + None, + None, + Some( + post_update( + None, + Some(Content::None), + Some(true)) + ) + ) + ); + + let post_ids = Posts::find_unlisted_post_ids_in_space(SPACE1, 0, 0); + assert_eq!(post_ids, vec![]); + }); +}*/ +// -------------------------------------------------------------------------------------------- diff --git a/pallets/posts/tests/src/shared_posts_tests.rs b/pallets/posts/tests/src/shared_posts_tests.rs new file mode 100644 index 0000000..b4d1825 --- /dev/null +++ b/pallets/posts/tests/src/shared_posts_tests.rs @@ -0,0 +1,180 @@ +use frame_support::{assert_noop, assert_ok}; + +use pallet_permissions::SpacePermission as SP; +use pallet_posts::Error as PostsError; + +use crate::{mock::*, tests_utils::*}; + +#[test] +fn share_post_should_work() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_create_space(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None)); // SpaceId 2 by ACCOUNT2 + + assert_ok!(_create_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + Some(Some(SPACE2)), + Some(extension_shared_post(POST1)), + None + )); // Share PostId 1 on SpaceId 2 by ACCOUNT2 which is permitted by default in both spaces + + // Check storages + assert_eq!(Posts::post_ids_by_space_id(SPACE1), vec![POST1]); + assert_eq!(Posts::post_ids_by_space_id(SPACE2), vec![POST2]); + assert_eq!(Posts::next_post_id(), POST3); + + assert_eq!(Posts::shared_post_ids_by_original_post_id(POST1), vec![POST2]); + + let shared_post = Posts::post_by_id(POST2).unwrap(); + + assert_eq!(shared_post.space_id, Some(SPACE2)); + assert_eq!(shared_post.created.account, ACCOUNT2); + assert_eq!(shared_post.extension, extension_shared_post(POST1)); + }); +} + +#[test] +fn share_post_should_work_when_one_of_roles_is_permitted() { + ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::CreatePosts]).execute_with( + || { + assert_ok!(_create_space( + None, // From ACCOUNT1 + None, // With default space content, + None + )); + // SpaceId 2 + assert_ok!(_create_post( + None, // From ACCOUNT1 + Some(Some(SPACE2)), + None, // With RegularPost extension + None // With default post content + )); // PostId 1 on SpaceId 2 + + assert_ok!(_create_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + Some(Some(SPACE1)), + Some(extension_shared_post(POST1)), + None + )); // Share PostId 1 on SpaceId 1 by ACCOUNT2 which is permitted by RoleId 1 from ext + }, + ); +} + +#[test] +fn share_post_should_work_for_share_own_post_in_same_own_space() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_create_post( + Some(RuntimeOrigin::signed(ACCOUNT1)), + Some(Some(SPACE1)), + Some(extension_shared_post(POST1)), + None + )); // Share PostId 1 + + // Check storages + assert_eq!(Posts::post_ids_by_space_id(SPACE1), vec![POST1, POST2]); + assert_eq!(Posts::next_post_id(), POST3); + + assert_eq!(Posts::shared_post_ids_by_original_post_id(POST1), vec![POST2]); + + let shared_post = Posts::post_by_id(POST2).unwrap(); + assert_eq!(shared_post.space_id, Some(SPACE1)); + assert_eq!(shared_post.created.account, ACCOUNT1); + assert_eq!(shared_post.extension, extension_shared_post(POST1)); + }); +} + +#[test] +fn share_post_should_fail_when_original_post_not_found() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!(_create_space(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None)); // SpaceId 2 by ACCOUNT2 + + // Skipped creating PostId 1 + assert_noop!( + _create_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + Some(Some(SPACE2)), + Some(extension_shared_post(POST1)), + None + ), + PostsError::::OriginalPostNotFound + ); + }); +} + +#[test] +fn share_post_should_fail_when_trying_to_share_shared_post() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_create_space(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None)); // SpaceId 2 by ACCOUNT2 + + assert_ok!(_create_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + Some(Some(SPACE2)), + Some(extension_shared_post(POST1)), + None + )); + + // Try to share post with extension SharedPost + assert_noop!( + _create_post( + Some(RuntimeOrigin::signed(ACCOUNT1)), + Some(Some(SPACE1)), + Some(extension_shared_post(POST2)), + None + ), + PostsError::::CannotShareSharedPost + ); + }); +} + +#[test] +fn share_post_should_fail_when_account_has_no_permission_to_create_posts_in_new_space() { + ExtBuilder::build_with_post().execute_with(|| { + assert_ok!(_create_space( + Some(RuntimeOrigin::signed(ACCOUNT1)), + None, // Default space content, + None + )); // SpaceId 2 by ACCOUNT1 + + // Try to share post with extension SharedPost + assert_noop!( + _create_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + Some(Some(SPACE2)), + Some(extension_shared_post(POST1)), + None + ), + PostsError::::NoPermissionToCreatePosts + ); + }); +} + +#[test] +fn share_post_should_fail_when_no_right_permission_in_account_roles() { + ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::CreatePosts]).execute_with( + || { + assert_ok!(_create_space( + None, // From ACCOUNT1 + None, // With default space content + None + )); + // SpaceId 2 + assert_ok!(_create_post( + None, // From ACCOUNT1 + Some(Some(SPACE2)), + None, // With RegularPost extension + None // With default post content + )); // PostId 1 on SpaceId 2 + + assert_ok!(_delete_default_role()); + + assert_noop!( + _create_post( + Some(RuntimeOrigin::signed(ACCOUNT2)), + Some(Some(SPACE1)), + Some(extension_shared_post(POST1)), + None + ), + PostsError::::NoPermissionToCreatePosts + ); + }, + ); +} diff --git a/pallets/posts/tests/src/tests_utils.rs b/pallets/posts/tests/src/tests_utils.rs new file mode 100644 index 0000000..98e9b4c --- /dev/null +++ b/pallets/posts/tests/src/tests_utils.rs @@ -0,0 +1,488 @@ +use std::{ + cell::RefCell, + collections::HashMap, + hash::{Hash, Hasher}, +}; + +use frame_support::{assert_ok, pallet_prelude::*}; +use sp_core::storage::Storage; +use sp_io::TestExternalities; + +use pallet_permissions::{SpacePermission as SP, SpacePermission, SpacePermissions}; +use pallet_posts::{Comment, PostExtension, PostUpdate}; +use pallet_spaces::types::SpaceUpdate; +use subsocial_support::{ + mock_functions::*, + traits::{IsAccountBlocked, IsContentBlocked, IsPostBlocked, IsSpaceBlocked}, + Content, PostId, SpaceId, User, +}; + +use crate::mock::*; + +////// Ext Builder + +pub struct ExtBuilder; + +impl ExtBuilder { + fn configure_storages(storage: &mut Storage) { + let mut accounts = Vec::new(); + for account in ACCOUNT1..=ACCOUNT2 { + accounts.push(account); + } + + let _ = pallet_balances::GenesisConfig:: { + balances: accounts.iter().cloned().map(|k| (k, 100)).collect(), + } + .assimilate_storage(storage); + } + + /// Default ext configuration with BlockNumber 1 + pub fn build() -> TestExternalities { + let mut storage = frame_system::GenesisConfig::default().build_storage::().unwrap(); + + Self::configure_storages(&mut storage); + + let mut ext = TestExternalities::from(storage); + ext.execute_with(|| System::set_block_number(1)); + + ext + } + + fn add_default_space() { + assert_ok!(_create_default_space()); + } + + fn add_another_space() { + assert_ok!(_create_space_with_content(another_space_content_ipfs())); + } + + fn add_post() { + Self::add_default_space(); + assert_ok!(_create_default_post()); + } + + fn add_comment() { + Self::add_post(); + assert_ok!(_create_default_comment()); + } + + /// Custom ext configuration with SpaceId 1 and BlockNumber 1 + pub fn build_with_space() -> TestExternalities { + let mut ext = Self::build(); + ext.execute_with(Self::add_default_space); + ext + } + + /// Custom ext configuration with SpaceId 1, PostId 1 and BlockNumber 1 + pub fn build_with_post() -> TestExternalities { + let mut ext = Self::build(); + ext.execute_with(Self::add_post); + ext + } + + /// Custom ext configuration with SpaceId 1, PostId 1, PostId 2 (as comment) and BlockNumber 1 + pub fn build_with_comment() -> TestExternalities { + let mut ext = Self::build(); + ext.execute_with(Self::add_comment); + ext + } + + /// Custom ext configuration with SpaceId 1-2, PostId 1 where BlockNumber 1 + pub fn build_with_post_and_two_spaces() -> TestExternalities { + let mut ext = Self::build_with_post(); + ext.execute_with(Self::add_another_space); + ext + } + + /// Custom ext configuration with specified permissions granted (includes SpaceId 1) + pub fn build_with_a_few_roles_granted_to_account2(perms: Vec) -> TestExternalities { + let mut ext = Self::build_with_space(); + + ext.execute_with(|| { + let user = User::Account(ACCOUNT2); + assert_ok!(_create_role(None, None, None, None, Some(perms))); + // RoleId 1 + assert_ok!(_create_default_role()); // RoleId 2 + + assert_ok!(_grant_role(None, Some(ROLE1), Some(vec![user.clone()]))); + assert_ok!(_grant_role(None, Some(ROLE2), Some(vec![user]))); + }); + + ext + } +} + +////// Consts + +pub(crate) const ACCOUNT1: AccountId = 1; +pub(crate) const ACCOUNT2: AccountId = 2; + +pub(crate) const SPACE1: SpaceId = 1001; +pub(crate) const SPACE2: SpaceId = 1002; + +pub(crate) const POST1: PostId = 1; +pub(crate) const POST2: PostId = 2; +pub(crate) const POST3: PostId = 3; + +type RoleId = u64; + +pub(crate) const ROLE1: RoleId = 1; +pub(crate) const ROLE2: RoleId = 2; + +////// Moderation Utils + +// Moderation pallet mocks + +/* ------------------------------------------------------------------------------------------------ */ +// Moderation tests + +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug)] +pub enum EntityId { + Content(Content), + Account(AccountId), + Space(SpaceId), + Post(PostId), +} + +impl Hash for EntityId { + fn hash(&self, state: &mut H) { + match self { + EntityId::Content(content) => match content { + Content::None => 0.hash(state), + Content::Other(content) => content.hash(state), + Content::IPFS(content) => content.hash(state), + }, + EntityId::Account(account) => account.hash(state), + EntityId::Space(space) => space.hash(state), + EntityId::Post(post) => post.hash(state), + } + } +} + +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, Hash)] +pub enum EntityStatus { + Allowed, + Blocked, +} + +thread_local! { + pub static MOCK_MODERATION_STATE: RefCell> = RefCell::new(Default::default()); +} +pub struct MockModeration; + +impl MockModeration { + fn set_entity_status(entity: EntityId, space: SpaceId, status: EntityStatus) { + MOCK_MODERATION_STATE.with(|mock_moderation_state| { + let mut mock_moderation_state = mock_moderation_state.borrow_mut(); + mock_moderation_state.insert((entity, space), status); + }); + } + + fn get_entity_status(id: EntityId, scope: SpaceId) -> Option { + MOCK_MODERATION_STATE.with(|mock_moderation_state| { + let mock_moderation_state = mock_moderation_state.borrow(); + let status = mock_moderation_state.get(&(id, scope)).cloned(); + status + }) + } + + fn is_allowed_entity(id: EntityId, scope: SpaceId) -> bool { + Self::get_entity_status(id, scope).unwrap_or(EntityStatus::Allowed) == EntityStatus::Allowed + } + + fn is_blocked_entity(id: EntityId, scope: SpaceId) -> bool { + Self::get_entity_status(id, scope) == Some(EntityStatus::Blocked) + } +} + +impl IsPostBlocked for MockModeration { + fn is_blocked_post(post_id: PostId, scope: SpaceId) -> bool { + Self::is_blocked_entity(EntityId::Post(post_id), scope) + } + + fn is_allowed_post(post_id: PostId, scope: SpaceId) -> bool { + Self::is_allowed_entity(EntityId::Post(post_id), scope) + } +} + +impl IsAccountBlocked for MockModeration { + fn is_blocked_account(account: AccountId, scope: SpaceId) -> bool { + Self::is_blocked_entity(EntityId::Account(account), scope) + } + + fn is_allowed_account(account: AccountId, scope: SpaceId) -> bool { + Self::is_allowed_entity(EntityId::Account(account), scope) + } +} + +impl IsSpaceBlocked for MockModeration { + fn is_blocked_space(space_id: SpaceId, scope: SpaceId) -> bool { + Self::is_blocked_entity(EntityId::Space(space_id), scope) + } + + fn is_allowed_space(space_id: SpaceId, scope: SpaceId) -> bool { + Self::is_allowed_entity(EntityId::Space(space_id), scope) + } +} + +impl IsContentBlocked for MockModeration { + fn is_blocked_content(content: Content, scope: SpaceId) -> bool { + Self::is_blocked_entity(EntityId::Content(content), scope) + } + + fn is_allowed_content(content: Content, scope: SpaceId) -> bool { + Self::is_allowed_entity(EntityId::Content(content), scope) + } +} + +pub(crate) fn block_account_in_space_1() { + MockModeration::set_entity_status(EntityId::Account(ACCOUNT1), SPACE1, EntityStatus::Blocked); +} + +pub(crate) fn block_content_in_space_1() { + MockModeration::set_entity_status( + EntityId::Content(valid_content_ipfs()), + SPACE1, + EntityStatus::Blocked, + ); +} + +///////////// Space Utils + +pub(crate) fn space_content_ipfs() -> Content { + Content::IPFS(b"bafyreib3mgbou4xln42qqcgj6qlt3cif35x4ribisxgq7unhpun525l54e".to_vec()) +} + +pub(crate) fn another_space_content_ipfs() -> Content { + Content::IPFS(b"bafyrelt3cif35x4ribisxgq7unhpun525l54eib3mgbou4xln42qqcgj6q".to_vec()) +} + +pub(crate) fn space_update(content: Option, hidden: Option) -> SpaceUpdate { + SpaceUpdate { content, hidden, permissions: None } +} + +pub(crate) fn _create_default_space() -> DispatchResult { + _create_space(None, None, None) +} + +pub(crate) fn _create_space( + origin: Option, + content: Option, + permissions: Option>, +) -> DispatchResult { + Spaces::create_space( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + content.unwrap_or_else(space_content_ipfs), + permissions.unwrap_or_default(), + ) +} + +pub(crate) fn _create_space_with_content(content: Content) -> DispatchResult { + _create_space(None, Some(content), None) +} + +pub(crate) fn _update_space( + origin: Option, + space_id: Option, + update: Option, +) -> DispatchResult { + Spaces::update_space( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + space_id.unwrap_or(SPACE1), + update.unwrap_or_else(|| space_update(None, None)), + ) +} + +///////////// Post Utils + +pub(crate) fn post_content_ipfs() -> Content { + Content::IPFS(b"bafyreidzue2dtxpj6n4x5mktrt7las5wz5diqma47zr25uau743dhe76we".to_vec()) +} + +pub(crate) fn updated_post_content() -> Content { + Content::IPFS(b"bafyreifw4omlqpr3nqm32bueugbodkrdne7owlkxgg7ul2qkvgrnkt3g3u".to_vec()) +} + +pub(crate) fn post_update( + space_id: Option, + content: Option, + hidden: Option, +) -> PostUpdate { + PostUpdate { space_id, content, hidden } +} + +pub(crate) fn comment_content_ipfs() -> Content { + Content::IPFS(b"bafyreib6ceowavccze22h2x4yuwagsnym2c66gs55mzbupfn73kd6we7eu".to_vec()) +} + +pub(crate) fn reply_content_ipfs() -> Content { + Content::IPFS(b"QmYA2fn8cMbVWo4v95RwcwJVyQsNtnEwHerfWR8UNtEwoE".to_vec()) +} + +pub(crate) fn extension_regular_post() -> PostExtension { + PostExtension::RegularPost +} + +pub(crate) fn extension_comment(parent_id: Option, root_post_id: PostId) -> PostExtension { + PostExtension::Comment(Comment { parent_id, root_post_id }) +} + +pub(crate) fn extension_shared_post(original_post_id: PostId) -> PostExtension { + PostExtension::SharedPost(original_post_id) +} + +pub(crate) fn _create_default_post() -> DispatchResult { + _create_post(None, None, None, None) +} + +pub(crate) fn _create_post( + origin: Option, + space_id_opt: Option>, + extension: Option, + content: Option, +) -> DispatchResult { + Posts::create_post( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + space_id_opt.unwrap_or(Some(SPACE1)), + extension.unwrap_or_else(extension_regular_post), + content.unwrap_or_else(post_content_ipfs), + ) +} + +pub(crate) fn _update_post( + origin: Option, + post_id: Option, + update: Option, +) -> DispatchResult { + Posts::update_post( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + post_id.unwrap_or(POST1), + update.unwrap_or_else(|| post_update(None, None, None)), + ) +} + +pub(crate) fn _move_post_1_to_space_2() -> DispatchResult { + _move_post(None, None, None) +} + +/// Move the post out of this space to nowhere (space = None). +pub(crate) fn _move_post_to_nowhere(post_id: PostId) -> DispatchResult { + _move_post(None, Some(post_id), Some(None)) +} + +pub(crate) fn _move_post( + origin: Option, + post_id: Option, + new_space_id: Option>, +) -> DispatchResult { + Posts::move_post( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + post_id.unwrap_or(POST1), + new_space_id.unwrap_or(Some(SPACE2)), + ) +} + +pub(crate) fn _create_default_comment() -> DispatchResult { + _create_comment(None, None, None, None) +} + +pub(crate) fn _create_comment( + origin: Option, + post_id: Option, + parent_id: Option>, + content: Option, +) -> DispatchResult { + _create_post( + origin, + Some(None), + Some(extension_comment(parent_id.unwrap_or_default(), post_id.unwrap_or(POST1))), + Some(content.unwrap_or_else(comment_content_ipfs)), + ) +} + +pub(crate) fn _update_comment( + origin: Option, + post_id: Option, + update: Option, +) -> DispatchResult { + _update_post( + origin, + Some(post_id.unwrap_or(POST2)), + Some(update.unwrap_or_else(|| post_update(None, Some(reply_content_ipfs()), None))), + ) +} + +/////// Roles utils + +pub(crate) fn default_role_content_ipfs() -> Content { + Content::IPFS(b"QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD4".to_vec()) +} + +pub fn _create_default_role() -> DispatchResult { + _create_role(None, None, None, None, None) +} + +pub fn _create_role( + origin: Option, + space_id: Option, + time_to_live: Option>, + content: Option, + permissions: Option>, +) -> DispatchResult { + // TODO: remove + Roles::create_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + space_id.unwrap_or(SPACE1), + time_to_live.unwrap_or_default(), // Should return 'None' + content.unwrap_or_else(default_role_content_ipfs), + permissions.unwrap_or_else(permission_set_default), + ) +} + +pub fn _grant_role( + origin: Option, + role_id: Option, + users: Option>>, +) -> DispatchResult { + Roles::grant_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + role_id.unwrap_or(ROLE1), + users.unwrap_or_else(|| vec![User::Account(ACCOUNT2)]), + ) +} + +pub fn _delete_default_role() -> DispatchResult { + _delete_role(None, None) +} + +pub fn _delete_role(origin: Option, role_id: Option) -> DispatchResult { + let users_count = Roles::users_by_role_id(role_id.unwrap_or(ROLE1)).len(); + Roles::delete_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + role_id.unwrap_or(ROLE1), + users_count as u32, + ) +} + +/////// Permissions utils + +/// Permissions Set that includes next permission: ManageRoles +pub(crate) fn permission_set_default() -> Vec { + vec![SP::ManageRoles] +} + +pub(crate) fn _transfer_default_space_ownership() -> DispatchResult { + _transfer_space_ownership(None, None, None) +} + +pub(crate) fn _transfer_space_ownership( + origin: Option, + space_id: Option, + transfer_to: Option, +) -> DispatchResult { + SpaceOwnership::transfer_space_ownership( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + space_id.unwrap_or(SPACE1), + transfer_to.unwrap_or(ACCOUNT2), + ) +} diff --git a/pallets/roles/Cargo.toml b/pallets/roles/Cargo.toml new file mode 100644 index 0000000..c863381 --- /dev/null +++ b/pallets/roles/Cargo.toml @@ -0,0 +1,57 @@ +[package] +name = 'pallet-roles' +version = '0.1.7' +authors = ['DappForce '] +edition = '2021' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Roles management pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[features] +default = ['std'] +runtime-benchmarks = [ + 'frame-benchmarking/runtime-benchmarks', + 'pallet-spaces', +] +std = [ + 'codec/std', + 'scale-info/std', + 'frame-benchmarking/std', + 'frame-support/std', + 'frame-system/std', + 'pallet-balances/std', + 'pallet-timestamp/std', + 'sp-runtime/std', + 'sp-std/std', + 'pallet-permissions/std', + 'subsocial-support/std', +] +try-runtime = ['frame-support/try-runtime'] + +[dependencies] +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } + +# Local dependencies +pallet-permissions = { default-features = false, path = '../permissions' } +pallet-spaces = { optional = true, default-features = false, path = '../spaces' } +subsocial-support = { default-features = false, path = '../support' } + +# Substrate dependencies +frame-benchmarking = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false, optional = true } +frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } + +[dev-dependencies] +serde = { version = '1.0.152' } + +pallet-balances = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-core = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-io = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +pallet-spaces = { default-features = false, path = '../spaces' } diff --git a/pallets/roles/rpc/Cargo.toml b/pallets/roles/rpc/Cargo.toml new file mode 100644 index 0000000..25c8226 --- /dev/null +++ b/pallets/roles/rpc/Cargo.toml @@ -0,0 +1,51 @@ +[package] +name = 'roles-rpc' +version = '0.7.3' +authors = ['DappForce '] +edition = '2018' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'RPC methods for the roles pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[dependencies.serde] +optional = true +features = ['derive'] +version = '1.0.119' + +[dependencies.codec] +default-features = false +features = ['derive'] +package = 'parity-scale-codec' +version = '2.0.0' + +[dependencies] +jsonrpc-core = '18.0.0' +jsonrpc-core-client = '18.0.0' +jsonrpc-derive = '18.0.0' + +# Local dependencies +pallet-permissions = { default-features = false, path = '../../permissions' } +pallet-utils = { default-features = false, path = '../../utils' } + +# Custom Runtime API +roles-runtime-api = { default-features = false, path = 'runtime-api' } + +# Substrate dependencies +sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-blockchain = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-rpc = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } + +[features] +default = ['std'] +std = [ + 'serde', + 'sp-runtime/std', + 'sp-api/std', + 'roles-runtime-api/std', + 'pallet-permissions/std', + 'pallet-utils/std', +] diff --git a/pallets/roles/rpc/runtime-api/Cargo.toml b/pallets/roles/rpc/runtime-api/Cargo.toml new file mode 100644 index 0000000..0dd3ab5 --- /dev/null +++ b/pallets/roles/rpc/runtime-api/Cargo.toml @@ -0,0 +1,43 @@ +[package] +name = 'roles-runtime-api' +version = '0.7.3' +authors = ['DappForce '] +edition = '2018' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Runtime API definition for the roles pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[dependencies.serde] +optional = true +features = ["derive"] +version = "1.0.119" + +[dependencies.codec] +default-features = false +features = ['derive'] +package = 'parity-scale-codec' +version = '2.0.0' + +[dependencies] +# Local dependencies +pallet-permissions = { default-features = false, path = '../../../permissions' } +pallet-utils = { default-features = false, path = '../../../utils' } + +# Substrate dependencies +sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } + +[features] +default = ['std'] +std = [ + 'serde', + 'sp-api/std', + 'sp-std/std', + 'sp-runtime/std', + 'pallet-permissions/std', + 'pallet-utils/std', +] diff --git a/pallets/roles/rpc/runtime-api/src/lib.rs b/pallets/roles/rpc/runtime-api/src/lib.rs new file mode 100644 index 0000000..551beab --- /dev/null +++ b/pallets/roles/rpc/runtime-api/src/lib.rs @@ -0,0 +1,18 @@ +#![cfg_attr(not(feature = "std"), no_std)] + +use codec::Codec; +use sp_std::vec::Vec; +use pallet_utils::SpaceId; +use pallet_permissions::SpacePermission; + +sp_api::decl_runtime_apis! { + pub trait RolesApi where + AccountId: Codec + { + fn get_space_permissions_by_account(account: AccountId, space_id: SpaceId) -> Vec; + + fn get_accounts_with_any_role_in_space(space_id: SpaceId) -> Vec; + + fn get_space_ids_for_account_with_any_role(account_id: AccountId) -> Vec; + } +} diff --git a/pallets/roles/rpc/src/lib.rs b/pallets/roles/rpc/src/lib.rs new file mode 100644 index 0000000..35991b5 --- /dev/null +++ b/pallets/roles/rpc/src/lib.rs @@ -0,0 +1,96 @@ +use std::sync::Arc; +use codec::Codec; +use sp_blockchain::HeaderBackend; +use sp_runtime::{generic::BlockId, traits::Block as BlockT}; +use jsonrpc_core::Result; +use jsonrpc_derive::rpc; +use sp_api::ProvideRuntimeApi; +use pallet_utils::{SpaceId, rpc::map_rpc_error}; +use pallet_permissions::SpacePermission; + +pub use roles_runtime_api::RolesApi as RolesRuntimeApi; + +#[rpc] +pub trait RolesApi { + #[rpc(name = "roles_getSpacePermissionsByAccount")] + fn get_space_permissions_by_account( + &self, + at: Option, + account: AccountId, + space_id: SpaceId + ) -> Result>; + + #[rpc(name = "roles_getAccountsWithAnyRoleInSpace")] + fn get_accounts_with_any_role_in_space( + &self, + at: Option, + space_id: SpaceId + ) -> Result>; + + #[rpc(name = "roles_getSpaceIdsForAccountWithAnyRole")] + fn get_space_ids_for_account_with_any_role( + &self, + at: Option, + account_id: AccountId + ) -> Result>; +} + +pub struct Roles { + client: Arc, + _marker: std::marker::PhantomData, +} + +impl Roles { + pub fn new(client: Arc) -> Self { + Self { + client, + _marker: Default::default(), + } + } +} + +impl RolesApi<::Hash, AccountId> + for Roles +where + Block: BlockT, + AccountId: Codec, + C: Send + Sync + 'static + ProvideRuntimeApi + HeaderBackend, + C::Api: RolesRuntimeApi, +{ + fn get_space_permissions_by_account( + &self, at: + Option<::Hash>, + account: AccountId, + space_id: SpaceId + ) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_space_permissions_by_account(&at, account, space_id); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_accounts_with_any_role_in_space( + &self, at: + Option<::Hash>, + space_id: SpaceId + ) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_accounts_with_any_role_in_space(&at, space_id); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_space_ids_for_account_with_any_role( + &self, at: + Option<::Hash>, + account_id: AccountId + ) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_space_ids_for_account_with_any_role(&at, account_id); + runtime_api_result.map_err(map_rpc_error) + } +} diff --git a/pallets/roles/src/benchmarking.rs b/pallets/roles/src/benchmarking.rs new file mode 100644 index 0000000..f103260 --- /dev/null +++ b/pallets/roles/src/benchmarking.rs @@ -0,0 +1,146 @@ +//! Roles pallet benchmarking. + +#![cfg(feature = "runtime-benchmarks")] + +// FIXME: refactor once SpacesInterface is added. + +use super::*; +use frame_benchmarking::{account, benchmarks}; +use frame_support::dispatch::DispatchError; +use frame_system::RawOrigin; +use pallet_permissions::SpacePermission as SP; +use pallet_spaces::types::Space; +use sp_std::{prelude::Vec, vec}; +use subsocial_support::{Content, User}; +use subsocial_support::mock_functions::{valid_content_ipfs, another_valid_content_ipfs}; + +fn create_dummy_space( + origin: RawOrigin, +) -> Result, DispatchError> { + let space_id = pallet_spaces::NextSpaceId::::get(); + + pallet_spaces::Pallet::::create_space(origin.into(), Content::None, None)?; + + let space = pallet_spaces::SpaceById::::get(space_id) + .ok_or(DispatchError::Other("Space not found"))?; + + Ok(space) +} + +fn dummy_list_of_users(num_of_users: u32) -> Vec> { + let mut users_to_grant = Vec::>::new(); + + for i in 1..num_of_users + 1 { + let user = account("user", i * 2 - 1, i * 2); + users_to_grant.push(User::Account(user)); + } + + users_to_grant +} + +fn create_dummy_role( + origin: RawOrigin, + space_id: SpaceId, + num_of_users: u32, +) -> Result<(Role, Vec>), DispatchError> { + let role_id = NextRoleId::::get(); + + Pallet::::create_role( + origin.clone().into(), + space_id, + Some(100u32.into()), + Content::None, + vec![SP::ManageRoles], + )?; + + let role = RoleById::::get(role_id).ok_or(DispatchError::Other("Role not found"))?; + + let users_to_grant = dummy_list_of_users::(num_of_users); + + if !users_to_grant.is_empty() { + Pallet::::grant_role(origin.into(), role.id, users_to_grant.clone())?; + } + + Ok((role, users_to_grant)) +} + +benchmarks! { + where_clause { where T: pallet_spaces::Config } + + create_role { + let caller_origin = RawOrigin::Signed(account::("Acc1", 1, 0)); + let space = create_dummy_space::(caller_origin.clone())?; + let time_to_live: Option = Some(100u32.into()); + let content = valid_content_ipfs(); + let perms = vec![SP::ManageRoles]; + let role_id = NextRoleId::::get(); + }: _(caller_origin, space.id, time_to_live, content, perms) + verify { + let role = RoleById::::get(role_id).unwrap(); + let space_roles_ids = RoleIdsBySpaceId::::get(space.id); + + ensure!(role.id == role_id, "Role id doesn't match"); + ensure!(space_roles_ids.contains(&role_id), "Role id not in space roles"); + } + + update_role { + let caller_origin = RawOrigin::Signed(account::("Acc1", 1, 0)); + let space = create_dummy_space::(caller_origin.clone())?; + let (role, _) = create_dummy_role::(caller_origin.clone(), space.id, 10)?; + + ensure!(!role.disabled, "Role should be enabled"); + + let update = RoleUpdate { + disabled: true.into(), + content: another_valid_content_ipfs().into(), + permissions: None + }; + }: _(caller_origin, role.id, update) + verify { + let role = RoleById::::get(role.id).unwrap(); + ensure!(role.disabled, "Role should be disabled"); + } + + delete_role { + let x in 0..T::MaxUsersToProcessPerDeleteRole::get().into(); + let caller_origin = RawOrigin::Signed(account::("Acc1", 1, 0)); + let space = create_dummy_space::(caller_origin.clone())?; + let (role, _) = create_dummy_role::(caller_origin.clone(), space.id, x)?; + }: _(caller_origin, role.id, x) + verify { + let deleted = RoleById::::get(role.id).is_none(); + ensure!(deleted, "Role should be deleted"); + } + + grant_role { + let x in 1..500; + let caller_origin = RawOrigin::Signed(account::("Acc1", 1, 0)); + let space = create_dummy_space::(caller_origin.clone())?; + let (role, _) = create_dummy_role::(caller_origin.clone(), space.id, 0)?; + + let users_to_grant = dummy_list_of_users::(x); + }: _(caller_origin, role.id, users_to_grant.clone()) + verify { + let granted_users = UsersByRoleId::::get(role.id); + for user in users_to_grant { + ensure!(granted_users.contains(&user), "Role should be granted"); + } + } + + revoke_role { + let x in 1..500; + let caller_origin = RawOrigin::Signed(account::("Acc1", 1, 0)); + let space = create_dummy_space::(caller_origin.clone())?; + let (role, users_to_revoke) = create_dummy_role::(caller_origin.clone(), space.id, x)?; + }: _(caller_origin, role.id, users_to_revoke) + verify { + let granted_users = UsersByRoleId::::get(role.id); + ensure!(granted_users.is_empty(), "Role should have zero users"); + } + + impl_benchmark_test_suite!( + Pallet, + crate::mock::ExtBuilder::build(), + crate::mock::Test, + ); +} diff --git a/pallets/roles/src/functions.rs b/pallets/roles/src/functions.rs new file mode 100644 index 0000000..5cd98e1 --- /dev/null +++ b/pallets/roles/src/functions.rs @@ -0,0 +1,187 @@ +use super::*; + +use frame_support::dispatch::DispatchError; +use pallet_permissions::SpacePermissionsContext; + +impl Pallet { + /// Check that there is a `Role` with such `role_id` in the storage + /// or return`RoleNotFound` error. + pub fn ensure_role_exists(role_id: RoleId) -> DispatchResult { + ensure!(>::contains_key(role_id), Error::::RoleNotFound); + Ok(()) + } + + /// Get `Role` by id from the storage or return `RoleNotFound` error. + pub fn require_role(role_id: RoleId) -> Result, DispatchError> { + Ok(Self::role_by_id(role_id).ok_or(Error::::RoleNotFound)?) + } + + /// Ensure that this account is not blocked and has 'ManageRoles' permission in a given space + pub fn ensure_role_manager(account: T::AccountId, space_id: SpaceId) -> DispatchResult { + ensure!( + T::IsAccountBlocked::is_allowed_account(account.clone(), space_id), + ModerationError::AccountIsBlocked + ); + Self::ensure_user_has_space_permission_with_load_space( + User::Account(account), + space_id, + SpacePermission::ManageRoles, + Error::::NoPermissionToManageRoles.into(), + ) + } + + fn ensure_user_has_space_permission_with_load_space( + user: User, + space_id: SpaceId, + permission: SpacePermission, + error: DispatchError, + ) -> DispatchResult { + let space = T::SpacePermissionsProvider::space_permissions_info(space_id)?; + + let mut is_owner = false; + let mut is_follower = false; + + match &user { + User::Account(account) => { + is_owner = *account == space.owner; + + // No need to check if a user is follower, if they already are an owner: + is_follower = + is_owner || T::SpaceFollows::is_space_follower(account.clone(), space_id); + }, + User::Space(_) => (/* Not implemented yet. */), + } + + Self::ensure_user_has_space_permission( + user, + SpacePermissionsContext { + space_id, + is_space_owner: is_owner, + is_space_follower: is_follower, + space_perms: space.permissions, + }, + permission, + error, + ) + } + + fn ensure_user_has_space_permission( + user: User, + ctx: SpacePermissionsContext, + permission: SpacePermission, + error: DispatchError, + ) -> DispatchResult { + match Permissions::::has_user_a_space_permission(ctx.clone(), permission.clone()) { + Some(true) => return Ok(()), + Some(false) => return Err(error), + _ => (/* Need to check in dynamic roles */), + } + + Self::has_permission_in_space_roles(user, ctx.space_id, permission, error) + } + + fn has_permission_in_space_roles( + user: User, + space_id: SpaceId, + permission: SpacePermission, + error: DispatchError, + ) -> DispatchResult { + let role_ids = Self::role_ids_by_user_in_space(user, space_id); + + for role_id in role_ids { + if let Some(role) = Self::role_by_id(role_id) { + if role.disabled { + continue + } + + let mut is_expired = false; + if let Some(expires_at) = role.expires_at { + if expires_at <= >::block_number() { + is_expired = true; + } + } + + if !is_expired && role.permissions.contains(&permission) { + return Ok(()) + } + } + } + + Err(error) + } +} + +impl Role { + pub fn new( + created_by: T::AccountId, + space_id: SpaceId, + time_to_live: Option, + content: Content, + permissions: BTreeSet, + ) -> Result { + let role_id = Pallet::::next_role_id(); + + let mut expires_at: Option = None; + if let Some(ttl) = time_to_live { + expires_at = Some(ttl + >::block_number()); + } + + let new_role = Role:: { + created: new_who_and_when::(created_by), + id: role_id, + space_id, + disabled: false, + expires_at, + content, + permissions, + }; + + Ok(new_role) + } + + pub fn set_disabled(&mut self, disable: bool) -> DispatchResult { + if self.disabled && disable { + return Err(Error::::RoleAlreadyDisabled.into()) + } else if !self.disabled && !disable { + return Err(Error::::RoleAlreadyEnabled.into()) + } + + self.disabled = disable; + + Ok(()) + } + + pub fn revoke_from_users(&self, users: Vec>) { + let mut users_by_role = >::take(self.id); + + for user in users.iter() { + let role_idx_by_user_opt = Pallet::::role_ids_by_user_in_space(&user, self.space_id) + .iter() + .position(|x| *x == self.id); + + if let Some(role_idx) = role_idx_by_user_opt { + >::mutate(user, self.space_id, |n| n.swap_remove(role_idx)); + } + + let user_idx_by_role_opt = users_by_role.iter().position(|x| x == user); + + if let Some(user_idx) = user_idx_by_role_opt { + users_by_role.swap_remove(user_idx); + } + } + >::insert(self.id, users_by_role); + } +} + +impl PermissionChecker for Pallet { + type AccountId = T::AccountId; + + fn ensure_user_has_space_permission( + user: User, + ctx: SpacePermissionsContext, + permission: SpacePermission, + error: DispatchError, + ) -> DispatchResult { + Self::ensure_user_has_space_permission(user, ctx, permission, error) + } +} diff --git a/pallets/roles/src/lib.rs b/pallets/roles/src/lib.rs new file mode 100644 index 0000000..60e8276 --- /dev/null +++ b/pallets/roles/src/lib.rs @@ -0,0 +1,490 @@ +//! # Roles Module +//! +//! This module allow you to create dynalic roles with an associated set of permissions +//! and grant them to users (accounts or space ids) within a given space. +//! +//! For example if you want to create a space that enables editors in a similar way to Medium, +//! you would create a role "Editor" with permissions such as `CreatePosts`, `UpdateAnyPost`, +//! and `HideAnyComment`. Then you would grant this role to the specific accounts you would like +//! to make editors. + +#![cfg_attr(not(feature = "std"), no_std)] + +use codec::{Decode, Encode}; +use frame_support::{dispatch::DispatchResult, ensure, traits::Get}; +use frame_system::{self as system, ensure_signed}; +use scale_info::TypeInfo; +use sp_runtime::RuntimeDebug; +use sp_std::{collections::btree_set::BTreeSet, prelude::*}; + +use pallet_permissions::{ + Pallet as Permissions, PermissionChecker, SpacePermission, SpacePermissionSet, +}; +use subsocial_support::{ + convert_users_vec_to_btree_set, ensure_content_is_valid, new_who_and_when, + traits::{IsAccountBlocked, IsContentBlocked, SpaceFollowsProvider, SpacePermissionsProvider}, + Content, ModerationError, SpaceId, User, WhoAndWhenOf, +}; + +pub use pallet::*; +pub mod functions; + +pub mod types; +pub use types::*; +// pub mod rpc; + +#[cfg(test)] +mod mock; + +#[cfg(feature = "runtime-benchmarks")] +mod benchmarking; +#[cfg(all(test, not(feature = "runtime-benchmarks")))] +mod tests; +pub mod weights; + +#[frame_support::pallet] +pub mod pallet { + use super::*; + use crate::weights::WeightInfo; + use frame_support::pallet_prelude::*; + use frame_system::pallet_prelude::*; + use pallet_permissions::SpacePermissionsInfoOf; + use subsocial_support::{remove_from_vec, WhoAndWhen}; + + #[pallet::config] + pub trait Config: + frame_system::Config + pallet_permissions::Config + pallet_timestamp::Config + { + /// The overarching event type. + type RuntimeEvent: From> + IsType<::RuntimeEvent>; + + /// When deleting a role via `delete_role()` dispatch, this parameter is checked. + /// If the number of users that own a given role is greater or equal to this number, + /// then `TooManyUsersToDeleteRole` error will be returned and the dispatch will fail. + #[pallet::constant] + type MaxUsersToProcessPerDeleteRole: Get; + + type SpacePermissionsProvider: SpacePermissionsProvider< + Self::AccountId, + SpacePermissionsInfoOf, + >; + + type SpaceFollows: SpaceFollowsProvider; + + type IsAccountBlocked: IsAccountBlocked; + + type IsContentBlocked: IsContentBlocked; + + /// Weight information for extrinsics in this pallet. + type WeightInfo: WeightInfo; + } + + #[pallet::pallet] + #[pallet::generate_store(pub(super) trait Store)] + #[pallet::without_storage_info] + pub struct Pallet(_); + + #[pallet::event] + #[pallet::generate_deposit(pub(super) fn deposit_event)] + pub enum Event { + RoleCreated { account: T::AccountId, space_id: SpaceId, role_id: RoleId }, + RoleUpdated { account: T::AccountId, role_id: RoleId }, + RoleDeleted { account: T::AccountId, role_id: RoleId }, + RoleGranted { account: T::AccountId, role_id: RoleId, users: Vec> }, + RoleRevoked { account: T::AccountId, role_id: RoleId, users: Vec> }, + } + + #[pallet::error] + pub enum Error { + /// Role was not found by id. + RoleNotFound, + + /// `NextRoleId` exceeds its maximum value. + RoleIdOverflow, + + /// Account does not have permission to manage roles in this space. + NoPermissionToManageRoles, + + /// Nothing to update in role. + NoUpdatesProvided, + + /// No permissions provided when trying to create a new role. + /// A role must have at least one permission. + NoPermissionsProvided, + + /// No users provided when trying to grant a role. + /// A role must be granted/revoked to/from at least one user. + NoUsersProvided, + + /// Canot remove a role from this many users in a single transaction. + /// See `MaxUsersToProcessPerDeleteRole` parameter of this trait. + TooManyUsersToDeleteRole, + + /// The user count sent doesn't match the real user count. + IncorrectUserCount, + + /// Cannot disable a role that is already disabled. + RoleAlreadyDisabled, + + /// Cannot enable a role that is already enabled. + RoleAlreadyEnabled, + } + + #[pallet::type_value] + pub fn DefaultForNextRoleId() -> RoleId { + FIRST_ROLE_ID + } + + /// The next role id. + #[pallet::storage] + #[pallet::getter(fn next_role_id)] + pub type NextRoleId = StorageValue<_, RoleId, ValueQuery, DefaultForNextRoleId>; + + /// Get the details of a role by its' id. + #[pallet::storage] + #[pallet::getter(fn role_by_id)] + pub type RoleById = StorageMap<_, Twox64Concat, RoleId, Role>; + + /// Get a list of all users (account or space ids) that a given role has been granted to. + #[pallet::storage] + #[pallet::getter(fn users_by_role_id)] + pub type UsersByRoleId = + StorageMap<_, Twox64Concat, RoleId, Vec>, ValueQuery>; + + // TODO: maybe use BoundedVec here? + /// Get a list of all role ids available in a given space. + #[pallet::storage] + #[pallet::getter(fn role_ids_by_space_id)] + pub type RoleIdsBySpaceId = + StorageMap<_, Twox64Concat, SpaceId, Vec, ValueQuery>; + + /// Get a list of all role ids owned by a given user (account or space id) + /// within a given space. + #[pallet::storage] + #[pallet::getter(fn role_ids_by_user_in_space)] + pub type RoleIdsByUserInSpace = StorageDoubleMap< + _, + Blake2_128Concat, + User, + Twox64Concat, + SpaceId, + Vec, + ValueQuery, + >; + + #[pallet::call] + impl Pallet { + /// Create a new role, with a list of permissions, within a given space. + /// + /// `content` can optionally contain additional information associated with a role, + /// such as a name, description, and image for a role. This may be useful for end users. + /// + /// Only the space owner or a user with `ManageRoles` permission can call this dispatch. + #[pallet::call_index(0)] + #[pallet::weight(::WeightInfo::create_role())] + pub fn create_role( + origin: OriginFor, + space_id: SpaceId, + time_to_live: Option, + content: Content, + permissions: Vec, + ) -> DispatchResult { + let who = ensure_signed(origin)?; + + ensure!(!permissions.is_empty(), Error::::NoPermissionsProvided); + + ensure_content_is_valid(content.clone())?; + ensure!( + T::IsContentBlocked::is_allowed_content(content.clone(), space_id), + ModerationError::ContentIsBlocked, + ); + + Self::ensure_role_manager(who.clone(), space_id)?; + + let permissions_set = permissions.into_iter().collect(); + let new_role = + Role::::new(who.clone(), space_id, time_to_live, content, permissions_set)?; + + // TODO review strange code: + let next_role_id = new_role.id.checked_add(1).ok_or(Error::::RoleIdOverflow)?; + NextRoleId::::put(next_role_id); + + RoleById::::insert(new_role.id, new_role.clone()); + RoleIdsBySpaceId::::mutate(space_id, |role_ids| role_ids.push(new_role.id)); + + Self::deposit_event(Event::RoleCreated { + account: who, + space_id, + role_id: new_role.id, + }); + Ok(()) + } + + /// Update an existing role by a given id. + /// Only the space owner or a user with `ManageRoles` permission can call this dispatch. + #[pallet::call_index(1)] + #[pallet::weight(::WeightInfo::update_role())] + pub fn update_role( + origin: OriginFor, + role_id: RoleId, + update: RoleUpdate, + ) -> DispatchResult { + let who = ensure_signed(origin)?; + + let has_updates = update.disabled.is_some() || + update.content.is_some() || + update.permissions.is_some(); + + ensure!(has_updates, Error::::NoUpdatesProvided); + + let mut role = Self::require_role(role_id)?; + + Self::ensure_role_manager(who.clone(), role.space_id)?; + + let mut is_update_applied = false; + + if let Some(disabled) = update.disabled { + if disabled != role.disabled { + role.set_disabled(disabled)?; + is_update_applied = true; + } + } + + if let Some(content) = update.content { + if content != role.content { + ensure_content_is_valid(content.clone())?; + ensure!( + T::IsContentBlocked::is_allowed_content(content.clone(), role.space_id), + ModerationError::ContentIsBlocked + ); + + role.content = content; + is_update_applied = true; + } + } + + if let Some(permissions) = update.permissions { + if !permissions.is_empty() { + let permissions_diff: Vec<_> = + permissions.symmetric_difference(&role.permissions).cloned().collect(); + + if !permissions_diff.is_empty() { + role.permissions = permissions; + is_update_applied = true; + } + } + } + + if is_update_applied { + >::insert(role_id, role); + Self::deposit_event(Event::RoleUpdated { account: who, role_id }); + } + Ok(()) + } + + /// Delete a given role and clean all associated storage items. + /// Only the space owner or a user with `ManageRoles` permission can call this dispatch. + #[pallet::call_index(2)] + #[pallet::weight(::WeightInfo::delete_role(*user_count))] + pub fn delete_role( + origin: OriginFor, + role_id: RoleId, + user_count: u32, + ) -> DispatchResult { + let who = ensure_signed(origin)?; + + let role = Self::require_role(role_id)?; + + Self::ensure_role_manager(who.clone(), role.space_id)?; + + let users = Self::users_by_role_id(role_id); + ensure!(users.len() as u32 == user_count, Error::::IncorrectUserCount); + ensure!( + users.len() <= T::MaxUsersToProcessPerDeleteRole::get() as usize, + Error::::TooManyUsersToDeleteRole + ); + + let role_idx_by_space_opt = + Self::role_ids_by_space_id(role.space_id).iter().position(|x| *x == role_id); + + if let Some(role_idx) = role_idx_by_space_opt { + RoleIdsBySpaceId::::mutate(role.space_id, |n| n.swap_remove(role_idx)); + } + + role.revoke_from_users(users); + + >::remove(role_id); + >::remove(role_id); + + Self::deposit_event(Event::RoleDeleted { account: who, role_id }); + Ok(()) + } + + /// Grant a given role to a list of users. + /// Only the space owner or a user with `ManageRoles` permission can call this dispatch. + #[pallet::call_index(3)] + #[pallet::weight(::WeightInfo::grant_role(users.len() as u32))] + pub fn grant_role( + origin: OriginFor, + role_id: RoleId, + users: Vec>, + ) -> DispatchResult { + let who = ensure_signed(origin)?; + + ensure!(!users.is_empty(), Error::::NoUsersProvided); + let users_set: BTreeSet> = convert_users_vec_to_btree_set(users)?; + + let role = Self::require_role(role_id)?; + + Self::ensure_role_manager(who.clone(), role.space_id)?; + + for user in users_set.iter() { + if !Self::users_by_role_id(role_id).contains(user) { + >::mutate(role_id, |users| { + users.push(user.clone()); + }); + } + if !Self::role_ids_by_user_in_space(user.clone(), role.space_id).contains(&role_id) + { + >::mutate(user.clone(), role.space_id, |roles| { + roles.push(role_id); + }) + } + } + + Self::deposit_event(Event::RoleGranted { + account: who, + role_id, + users: users_set.iter().cloned().collect(), + }); + Ok(()) + } + + /// Revoke a given role from a list of users. + /// Only the space owner or a user with `ManageRoles` permission can call this dispatch. + #[pallet::call_index(4)] + #[pallet::weight(::WeightInfo::revoke_role(users.len() as u32))] + pub fn revoke_role( + origin: OriginFor, + role_id: RoleId, + users: Vec>, + ) -> DispatchResult { + let who = ensure_signed(origin)?; + + ensure!(!users.is_empty(), Error::::NoUsersProvided); + + let role = Self::require_role(role_id)?; + + Self::ensure_role_manager(who.clone(), role.space_id)?; + + role.revoke_from_users(users.clone()); + + Self::deposit_event(Event::RoleRevoked { account: who, role_id, users }); + Ok(()) + } + + #[pallet::call_index(5)] + #[pallet::weight(( + Weight::from_ref_time(25_000) + T::DbWeight::get().reads_writes(1, 2), + DispatchClass::Operational, + Pays::Yes, + ))] + pub fn force_create_role( + origin: OriginFor, + created: WhoAndWhenOf, + role_id: RoleId, + space_id: SpaceId, + disabled: bool, + content: Content, + permissions: SpacePermissionSet, + ) -> DispatchResultWithPostInfo { + ensure_root(origin)?; + + let WhoAndWhen { account, time, .. } = created; + let new_who_and_when = WhoAndWhen { + account: account.clone(), + block: frame_system::Pallet::::block_number(), + time, + }; + + let new_role = Role:: { + created: new_who_and_when, + id: role_id, + space_id, + disabled, + expires_at: None, + content, + permissions, + }; + + if let Ok(role) = Self::require_role(role_id) { + if role.space_id != space_id { + RoleIdsBySpaceId::::mutate(role.space_id, |role_ids| { + remove_from_vec(role_ids, role_id) + }); + } + } + + RoleById::::insert(role_id, new_role); + RoleIdsBySpaceId::::mutate(space_id, |role_ids| role_ids.push(role_id)); + + Self::deposit_event(Event::RoleCreated { account, space_id, role_id }); + + Ok(Pays::No.into()) + } + + #[pallet::call_index(6)] + #[pallet::weight(( + Weight::from_ref_time(10_000) + T::DbWeight::get().writes(1), + DispatchClass::Operational, + Pays::Yes, + ))] + pub fn force_grant_role( + origin: OriginFor, + role_id: RoleId, + users: Vec>, + ) -> DispatchResultWithPostInfo { + ensure_root(origin)?; + + let space_id = Self::require_role(role_id)?.space_id; + let space = T::SpacePermissionsProvider::space_permissions_info(space_id)?; + + let users_set: BTreeSet> = convert_users_vec_to_btree_set(users)?; + + for user in users_set.iter() { + if !Self::users_by_role_id(role_id).contains(user) { + >::mutate(role_id, |users| { + users.push(user.clone()); + }); + } + if !Self::role_ids_by_user_in_space(user.clone(), space_id).contains(&role_id) { + >::mutate(user.clone(), space_id, |roles| { + roles.push(role_id); + }) + } + } + + Self::deposit_event(Event::RoleGranted { + account: space.owner, + role_id, + users: users_set.iter().cloned().collect(), + }); + Ok(Pays::No.into()) + } + + #[pallet::call_index(7)] + #[pallet::weight(( + Weight::from_ref_time(10_000) + T::DbWeight::get().writes(1), + DispatchClass::Operational, + Pays::Yes, + ))] + pub fn force_set_next_role_id( + origin: OriginFor, + role_id: RoleId, + ) -> DispatchResultWithPostInfo { + ensure_root(origin)?; + NextRoleId::::put(role_id); + Ok(Pays::No.into()) + } + } +} diff --git a/pallets/roles/src/mock.rs b/pallets/roles/src/mock.rs new file mode 100644 index 0000000..7d00783 --- /dev/null +++ b/pallets/roles/src/mock.rs @@ -0,0 +1,345 @@ +use super::*; + +use sp_core::H256; +use sp_io::TestExternalities; +use sp_std::{collections::btree_set::BTreeSet, prelude::Vec}; + +use frame_support::{ + assert_ok, + dispatch::{DispatchError, DispatchResult}, + parameter_types, + traits::{ConstU32, Everything}, +}; +use sp_runtime::{ + testing::Header, + traits::{BlakeTwo256, IdentityLookup}, +}; + +use pallet_permissions::{SpacePermission, SpacePermission as SP, SpacePermissions}; +use subsocial_support::{ + traits::{SpaceFollowsProvider, SpacePermissionsProvider as SpacePermissionsProviderT}, + Content, SpaceId, SpacePermissionsInfo, User, +}; + +use crate as roles; + +type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; +type Block = frame_system::mocking::MockBlock; + +frame_support::construct_runtime!( + pub enum Test where + Block = Block, + NodeBlock = Block, + UncheckedExtrinsic = UncheckedExtrinsic, + { + System: system::{Pallet, Call, Config, Storage, Event}, + Balances: pallet_balances::{Pallet, Call, Storage, Config, Event}, + Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent}, + Roles: roles::{Pallet, Call, Storage, Event}, + Spaces: pallet_spaces::{Pallet, Call, Storage, Event}, + } +); + +pub(super) type AccountId = u64; +pub(super) type Balance = u64; +type BlockNumber = u64; + +parameter_types! { + pub const BlockHashCount: u64 = 250; + pub const SS58Prefix: u8 = 42; +} + +impl frame_system::Config for Test { + type BaseCallFilter = Everything; + type BlockWeights = (); + type BlockLength = (); + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + type Index = u64; + type BlockNumber = BlockNumber; + type Hash = H256; + type Hashing = BlakeTwo256; + type AccountId = AccountId; + type Lookup = IdentityLookup; + type Header = Header; + type RuntimeEvent = RuntimeEvent; + type BlockHashCount = BlockHashCount; + type DbWeight = (); + type Version = (); + type PalletInfo = PalletInfo; + type AccountData = pallet_balances::AccountData; + type OnNewAccount = (); + type OnKilledAccount = (); + type SystemWeightInfo = (); + type SS58Prefix = SS58Prefix; + type OnSetCode = (); + type MaxConsumers = frame_support::traits::ConstU32<16>; +} + +parameter_types! { + pub const MinimumPeriod: u64 = 5; +} + +impl pallet_timestamp::Config for Test { + type Moment = u64; + type OnTimestampSet = (); + type MinimumPeriod = MinimumPeriod; + type WeightInfo = (); +} + +parameter_types! { + pub const ExistentialDeposit: u64 = 1; +} + +impl pallet_balances::Config for Test { + type Balance = u64; + type DustRemoval = (); + type RuntimeEvent = RuntimeEvent; + type ExistentialDeposit = ExistentialDeposit; + type AccountStore = System; + type WeightInfo = (); + type MaxLocks = (); + type MaxReserves = (); + type ReserveIdentifier = (); +} + +use pallet_permissions::default_permissions::DefaultSpacePermissions; + +impl pallet_permissions::Config for Test { + type DefaultSpacePermissions = DefaultSpacePermissions; +} + +parameter_types! { + pub const MaxUsersToProcessPerDeleteRole: u16 = 20; +} + +impl Config for Test { + type RuntimeEvent = RuntimeEvent; + type MaxUsersToProcessPerDeleteRole = MaxUsersToProcessPerDeleteRole; + #[cfg(feature = "runtime-benchmarks")] + type SpacePermissionsProvider = Spaces; + #[cfg(not(feature = "runtime-benchmarks"))] + type SpacePermissionsProvider = Self; + type SpaceFollows = Roles; + type IsAccountBlocked = (); + type IsContentBlocked = (); + type WeightInfo = (); +} + +impl pallet_spaces::Config for Test { + type RuntimeEvent = RuntimeEvent; + type Roles = Roles; + type SpaceFollows = Roles; + type IsAccountBlocked = (); + type IsContentBlocked = (); + type MaxSpacesPerAccount = ConstU32<100>; + type WeightInfo = (); +} + +impl SpacePermissionsProviderT> + for Test +{ + // This function should return an error every time Space doesn't exist by SpaceId + // Currently, we have a list of valid space id's to check + fn space_permissions_info( + id: SpaceId, + ) -> Result, DispatchError> { + if valid_space_ids().contains(&id) { + return Ok(SpacePermissionsInfo { owner: ACCOUNT1, permissions: None }) + } + + Err("mock:SpaceNotFound".into()) + } + + fn ensure_space_owner(id: SpaceId, account: &AccountId) -> DispatchResult { + if valid_space_ids().contains(&id) { + if *account == ACCOUNT1 { + return Ok(()) + } + } + + Err("mock:NotSpaceOwner".into()) + } +} + +impl SpaceFollowsProvider for Pallet { + type AccountId = AccountId; + + fn is_space_follower(_account: Self::AccountId, _space_id: u64) -> bool { + true + } +} + +pub struct ExtBuilder; + +impl ExtBuilder { + pub fn build() -> TestExternalities { + let storage = system::GenesisConfig::default().build_storage::().unwrap(); + + let mut ext = TestExternalities::from(storage); + ext.execute_with(|| System::set_block_number(1)); + + ext + } + + pub fn build_with_a_few_roles_granted_to_account2() -> TestExternalities { + let storage = system::GenesisConfig::default().build_storage::().unwrap(); + + let mut ext = TestExternalities::from(storage); + ext.execute_with(|| { + System::set_block_number(1); + let user = User::Account(ACCOUNT2); + + assert_ok!(_create_role(None, None, None, None, Some(self::permission_set_random()))); // RoleId 1 + assert_ok!(_create_default_role()); // RoleId 2 + + assert_ok!(_grant_role(None, Some(ROLE1), Some(vec![user.clone()]))); + assert_ok!(_grant_role(None, Some(ROLE2), Some(vec![user]))); + }); + + ext + } +} + +pub(crate) const ACCOUNT1: AccountId = 1; +pub(crate) const ACCOUNT2: AccountId = 2; +pub(crate) const ACCOUNT3: AccountId = 3; + +pub(crate) const ROLE1: RoleId = 1; +pub(crate) const ROLE2: RoleId = 2; +pub(crate) const ROLE3: RoleId = 3; +pub(crate) const ROLE4: RoleId = 4; + +pub(crate) const SPACE1: SpaceId = 1; +pub(crate) const SPACE2: SpaceId = 2; + +pub(crate) fn default_role_content_ipfs() -> Content { + Content::IPFS(b"QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD4".to_vec()) +} + +pub(crate) fn updated_role_content_ipfs() -> Content { + Content::IPFS(b"QmZENA8YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDaazhR8".to_vec()) +} + +pub(crate) fn invalid_role_content_ipfs() -> Content { + Content::IPFS(b"QmRAQB6DaazhR8".to_vec()) +} + +/// Permissions Set that includes next permission: ManageRoles +pub(crate) fn permission_set_default() -> Vec { + vec![SP::ManageRoles] +} + +/// Permissions Set that includes next permissions: ManageRoles, CreatePosts +pub(crate) fn permission_set_updated() -> Vec { + vec![SP::ManageRoles, SP::CreatePosts] +} + +/// Permissions Set that includes random permissions +pub(crate) fn permission_set_random() -> Vec { + vec![SP::CreatePosts, SP::UpdateOwnPosts, SP::UpdateAnyPost, SP::UpdateEntityStatus] +} + +pub(crate) fn valid_space_ids() -> Vec { + vec![SPACE1] +} + +/// Permissions Set that includes nothing +pub(crate) fn permission_set_empty() -> Vec { + vec![] +} + +pub(crate) fn role_update( + disabled: Option, + content: Option, + permissions: Option>, +) -> RoleUpdate { + RoleUpdate { disabled, content, permissions } +} + +pub(crate) fn _create_default_role() -> DispatchResult { + _create_role(None, None, None, None, None) +} + +pub(crate) fn _create_role( + origin: Option, + space_id: Option, + time_to_live: Option>, + content: Option, + permissions: Option>, +) -> DispatchResult { + Roles::create_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + space_id.unwrap_or(SPACE1), + time_to_live.unwrap_or_default(), // Should return 'None' + content.unwrap_or_else(self::default_role_content_ipfs), + permissions.unwrap_or_else(self::permission_set_default), + ) +} + +pub(crate) fn _update_default_role() -> DispatchResult { + _update_role(None, None, None) +} + +pub(crate) fn _update_role( + origin: Option, + role_id: Option, + update: Option, +) -> DispatchResult { + Roles::update_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + role_id.unwrap_or(ROLE1), + update.unwrap_or_else(|| { + self::role_update( + Some(true), + Some(self::updated_role_content_ipfs()), + Some(self::permission_set_updated().into_iter().collect()), + ) + }), + ) +} + +pub(crate) fn _grant_default_role() -> DispatchResult { + _grant_role(None, None, None) +} + +pub(crate) fn _grant_role( + origin: Option, + role_id: Option, + users: Option>>, +) -> DispatchResult { + Roles::grant_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + role_id.unwrap_or(ROLE1), + users.unwrap_or_else(|| vec![User::Account(ACCOUNT2)]), + ) +} + +pub(crate) fn _revoke_default_role() -> DispatchResult { + _revoke_role(None, None, None) +} + +pub(crate) fn _revoke_role( + origin: Option, + role_id: Option, + users: Option>>, +) -> DispatchResult { + Roles::revoke_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + role_id.unwrap_or(ROLE1), + users.unwrap_or_else(|| vec![User::Account(ACCOUNT2)]), + ) +} + +pub(crate) fn _delete_default_role() -> DispatchResult { + _delete_role(None, None) +} + +pub(crate) fn _delete_role(origin: Option, role_id: Option) -> DispatchResult { + let role_id = role_id.unwrap_or(ROLE1); + Roles::delete_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + role_id, + UsersByRoleId::::get(role_id).len() as u32, + ) +} diff --git a/pallets/roles/src/rpc.rs b/pallets/roles/src/rpc.rs new file mode 100644 index 0000000..300738c --- /dev/null +++ b/pallets/roles/src/rpc.rs @@ -0,0 +1,47 @@ +use crate::{Config, Pallet, Role, RoleIdsByUserInSpace}; + +use frame_support::storage::IterableStorageDoubleMap; +use sp_std::prelude::*; +use sp_std::collections::{ btree_set::BTreeSet }; + +use pallet_utils::{SpaceId, User}; +use pallet_permissions::{SpacePermission}; + +impl Pallet { + pub fn get_space_permissions_by_account( + account: T::AccountId, + space_id: SpaceId + ) -> Vec { + + Self::role_ids_by_user_in_space(User::Account(account), space_id) + .iter() + .filter_map(Self::role_by_id) + .flat_map(|role: Role| role.permissions.into_iter()) + .collect::>() + .iter().cloned().collect() + } + + pub fn get_accounts_with_any_role_in_space(space_id: SpaceId) -> Vec { + + Self::role_ids_by_space_id(space_id) + .iter() + .flat_map(Self::users_by_role_id) + .filter_map(|user| user.maybe_account()) + .collect::>() + .iter().cloned().collect() + } + + pub fn get_space_ids_for_account_with_any_role(account_id: T::AccountId) -> Vec { + let user = &User::Account(account_id); + let mut space_ids = Vec::new(); + + RoleIdsByUserInSpace::::iter_prefix(user) + .for_each(|(space_id, role_ids)| { + if !role_ids.is_empty() { + space_ids.push(space_id); + } + }); + + space_ids + } +} \ No newline at end of file diff --git a/pallets/roles/src/tests.rs b/pallets/roles/src/tests.rs new file mode 100644 index 0000000..d4861be --- /dev/null +++ b/pallets/roles/src/tests.rs @@ -0,0 +1,567 @@ +use crate::{mock::*, *}; + +use frame_support::{assert_noop, assert_ok}; +use subsocial_support::ContentError; + +#[test] +fn create_role_should_work() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + + // Check whether Role is stored correctly + assert!(Roles::role_by_id(ROLE1).is_some()); + + // Check whether data in Role structure is correct + let role = Roles::role_by_id(ROLE1).unwrap(); + assert_eq!(Roles::next_role_id(), ROLE2); + + assert_eq!(role.space_id, SPACE1); + assert_eq!(role.disabled, false); + assert_eq!(role.content, self::default_role_content_ipfs()); + assert_eq!(role.permissions, self::permission_set_default().into_iter().collect()); + }); +} + +#[test] +fn create_role_should_work_with_a_few_roles() { + ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { + assert_ok!(_create_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // On SpaceId 1 + None, // Without time_to_live + None, // With default content + Some(self::permission_set_updated()) + )); // RoleId 3 + + // Check whether Role is stored correctly + assert!(Roles::role_by_id(ROLE3).is_some()); + + // Check whether data in Role structure is correct + let role = Roles::role_by_id(ROLE3).unwrap(); + assert_eq!(Roles::next_role_id(), ROLE4); + + assert_eq!(role.space_id, SPACE1); + assert_eq!(role.disabled, false); + assert_eq!(role.content, self::default_role_content_ipfs()); + assert_eq!(role.permissions, self::permission_set_updated().into_iter().collect()); + }); +} + +#[test] +fn create_role_should_fail_with_space_not_found() { + ExtBuilder::build().execute_with(|| { + assert_noop!( + _create_role( + None, // From ACCOUNT1 + Some(SPACE2), + None, // Without time_to_live + None, // With default content + None // With default permission set + ), + "mock:SpaceNotFound" + ); + }); +} + +#[test] +fn create_role_should_fail_with_no_permission() { + ExtBuilder::build().execute_with(|| { + assert_noop!( + _create_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // On SpaceId 1 + None, // Without time_to_live + None, // With default content + None // With default permission set + ), + Error::::NoPermissionToManageRoles + ); + }); +} + +#[test] +fn create_role_should_fail_with_no_permissions_provided() { + ExtBuilder::build().execute_with(|| { + assert_noop!( + _create_role( + None, // From ACCOUNT1 + None, // On SpaceId 1 + None, // Without time_to_live + None, // With default permission set + Some(self::permission_set_empty()) + ), + Error::::NoPermissionsProvided + ); + }); +} + +#[test] +fn create_role_should_fail_with_ipfs_is_incorrect() { + ExtBuilder::build().execute_with(|| { + assert_noop!( + _create_role( + None, // From ACCOUNT1 + None, // On SpaceId 1 + None, // Without time_to_live + Some(self::invalid_role_content_ipfs()), + None // With default permissions set + ), + ContentError::InvalidIpfsCid + ); + }); +} + +#[test] +fn create_role_should_fail_with_a_few_roles_no_permission() { + ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { + assert_ok!(_delete_role(None, Some(ROLE2))); + assert_noop!( + _create_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // On SpaceId 1 + None, // Without time_to_live + None, // With default content + Some(self::permission_set_random()) + ), + Error::::NoPermissionToManageRoles + ); + }); +} + +#[test] +fn update_role_should_work() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_ok!(_update_default_role()); + + // Check whether Role is stored correctly + assert!(Roles::role_by_id(ROLE1).is_some()); + + // Check whether data in Role structure is correct + let role = Roles::role_by_id(ROLE1).unwrap(); + + assert_eq!(role.space_id, SPACE1); + assert_eq!(role.disabled, true); + assert_eq!(role.content, self::updated_role_content_ipfs()); + assert_eq!(role.permissions, self::permission_set_updated().into_iter().collect()); + }); +} + +#[test] +fn update_role_should_work_with_empty_perms_provided_no_changes() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_ok!(_update_role( + None, // From ACCOUNT1 + None, // On RoleId 1 + Some(self::role_update( + Some(true), + None, + Some(self::permission_set_empty().into_iter().collect()) + )) + )); + + // Check whether data in Role structure is correct + let role = Roles::role_by_id(ROLE1).unwrap(); + + assert_eq!(role.space_id, SPACE1); + assert_eq!(role.disabled, true); + assert_eq!(role.content, self::default_role_content_ipfs()); + assert_eq!(role.permissions, self::permission_set_default().into_iter().collect()); + }); +} + +#[test] +fn update_role_should_work_with_same_perms_provided_no_update() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_ok!( + _update_role( + None, // From ACCOUNT1 + None, // On RoleId 1 + Some( + self::role_update( + None, // No changes for disabled + None, // No content changes + Some(self::permission_set_default().into_iter().collect()) // The same permissions_set (no changes should apply) + ) + ) + ) + ); + + // Check whether data in Role structure is correct + let role = Roles::role_by_id(ROLE1).unwrap(); + + assert_eq!( + role.permissions, + self::permission_set_default().into_iter().collect() + ); + }); +} + +#[test] +fn update_role_should_work_with_a_few_roles() { + ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { + assert_ok!(_update_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + Some(ROLE1), + Some(self::role_update( + None, + None, + Some(self::permission_set_updated().into_iter().collect()) + )) + )); + + // Check whether Role is stored correctly + assert!(Roles::role_by_id(ROLE1).is_some()); + + // Check whether data in Role structure is correct + let role = Roles::role_by_id(ROLE1).unwrap(); + + assert_eq!(role.space_id, SPACE1); + assert_eq!(role.disabled, false); + assert_eq!(role.content, self::default_role_content_ipfs()); + assert_eq!(role.permissions, self::permission_set_updated().into_iter().collect()); + }); +} + +#[test] +fn update_role_should_work_not_updated_all_the_same() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_ok!(_update_role( + None, // From ACCOUNT1 + None, // On RoleId 1 + Some(self::role_update( + Some(false), + Some(self::default_role_content_ipfs()), + Some(self::permission_set_default().into_iter().collect()) + )) + )); + + // Check whether Role is stored correctly + assert!(Roles::role_by_id(ROLE1).is_some()); + + // Check whether data in Role structure is correct + let role = Roles::role_by_id(ROLE1).unwrap(); + + assert_eq!(role.space_id, SPACE1); + assert_eq!(role.disabled, false); + assert_eq!(role.content, self::default_role_content_ipfs()); + assert_eq!(role.permissions, self::permission_set_default().into_iter().collect()); + }); +} + +#[test] +fn update_role_should_fail_with_role_not_found() { + ExtBuilder::build().execute_with(|| { + assert_noop!(_update_default_role(), Error::::RoleNotFound); + }); +} + +#[test] +fn update_role_should_fail_with_no_permission() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_noop!( + _update_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // On RoleId 1 + None // With RoleUpdate that updates every mutable (updatable) field + ), + Error::::NoPermissionToManageRoles + ); + }); +} + +#[test] +fn update_role_should_fail_with_no_role_updates() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_noop!( + _update_role( + None, // From ACCOUNT1 + None, // On RoleId 1 + Some(self::role_update(None, None, None)) + ), + Error::::NoUpdatesProvided + ); + }); +} + +#[test] +fn update_role_should_fail_with_ipfs_is_incorrect() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_noop!( + _update_role( + None, // From ACCOUNT1 + None, // On RoleId 1 + Some(self::role_update(None, Some(self::invalid_role_content_ipfs()), None)) + ), + ContentError::InvalidIpfsCid + ); + }); +} + +#[test] +fn update_role_should_fail_with_a_few_roles_no_permission() { + ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { + assert_ok!(_delete_role(None, Some(ROLE2))); + assert_noop!( + _update_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // On RoleId 1 + Some(self::role_update( + None, + None, + Some(self::permission_set_default().into_iter().collect()) + )) + ), + Error::::NoPermissionToManageRoles + ); + }); +} + +#[test] +fn grant_role_should_work() { + ExtBuilder::build().execute_with(|| { + let user = User::Account(ACCOUNT2); + + assert_ok!(_create_default_role()); // RoleId 1 + assert_ok!(_grant_default_role()); // Grant RoleId 1 to ACCOUNT2 + + // Change whether data was stored correctly + assert_eq!(Roles::users_by_role_id(ROLE1), vec![user.clone()]); + assert_eq!(Roles::role_ids_by_user_in_space(user, SPACE1), vec![ROLE1]); + }); +} + +#[test] +fn grant_role_should_work_with_a_few_roles() { + ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { + let user = User::Account(ACCOUNT3); + assert_ok!(_grant_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // RoleId 1 + Some(vec![User::Account(ACCOUNT3)]) + )); + + // Check whether data is stored correctly + assert_eq!( + Roles::users_by_role_id(ROLE1), + vec![User::Account(ACCOUNT2), User::Account(ACCOUNT3)] + ); + assert_eq!(Roles::role_ids_by_user_in_space(user, SPACE1), vec![ROLE1]); + }); +} + +#[test] +fn grant_role_should_fail_with_role_not_found() { + ExtBuilder::build().execute_with(|| { + assert_noop!(_grant_default_role(), Error::::RoleNotFound); + }); +} + +#[test] +fn grant_role_should_fail_with_no_permission() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_noop!( + _grant_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // RoleId 1 + Some(vec![User::Account(ACCOUNT3)]) + ), + Error::::NoPermissionToManageRoles + ); + }); +} + +#[test] +fn grant_role_should_fail_with_no_users_provided() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_noop!( + _grant_role( + None, // From ACCOUNT1 + None, // RoleId 1 + Some(vec![]) + ), + Error::::NoUsersProvided + ); + }); +} + +#[test] +fn grant_role_should_fail_with_a_few_roles_no_permission() { + ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { + assert_ok!(_delete_role(None, Some(ROLE2))); + assert_noop!( + _grant_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // RoleId 1 + Some(vec![User::Account(ACCOUNT3)]) + ), + Error::::NoPermissionToManageRoles + ); + }); +} + +#[test] +fn revoke_role_should_work() { + ExtBuilder::build().execute_with(|| { + let user = User::Account(ACCOUNT2); + + assert_ok!(_create_default_role()); // RoleId 1 + assert_ok!(_grant_default_role()); // Grant RoleId 1 to ACCOUNT2 + assert_ok!(_revoke_default_role()); // Revoke RoleId 1 from ACCOUNT2 + + // Change whether data was stored correctly + assert!(Roles::users_by_role_id(ROLE1).is_empty()); + assert!(Roles::role_ids_by_user_in_space(user, SPACE1).is_empty()); + }); +} + +#[test] +fn revoke_role_should_work_with_a_few_roles() { + ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { + let user = User::Account(ACCOUNT3); + assert_ok!(_revoke_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // RoleId 1 + Some(vec![User::Account(ACCOUNT2)]) + )); + + // Check whether data is stored correctly + assert!(Roles::users_by_role_id(ROLE1).is_empty()); + assert!(Roles::role_ids_by_user_in_space(user, SPACE1).is_empty()); + }); +} + +#[test] +fn revoke_role_should_fail_with_role_not_found() { + ExtBuilder::build().execute_with(|| { + assert_noop!(_revoke_default_role(), Error::::RoleNotFound); + }); +} + +#[test] +fn revoke_role_should_fail_with_no_users_provided() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_noop!(_revoke_role(None, None, Some(vec![])), Error::::NoUsersProvided); + }); +} + +#[test] +fn revoke_role_should_fail_with_no_permission() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_noop!( + _revoke_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // RoleId 1 + Some(vec![User::Account(ACCOUNT3)]) + ), + Error::::NoPermissionToManageRoles + ); + }); +} + +#[test] +fn revoke_role_should_fail_with_a_few_roles_no_permission() { + ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { + assert_ok!(_delete_role(None, Some(ROLE2))); + assert_noop!( + _revoke_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, // RoleId 1 + Some(vec![User::Account(ACCOUNT3)]) + ), + Error::::NoPermissionToManageRoles + ); + }); +} + +#[test] +fn delete_role_should_work() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_ok!(_grant_default_role()); + assert_ok!(_delete_default_role()); + + // Check whether storages are cleaned up + assert!(Roles::role_by_id(ROLE1).is_none()); + assert!(Roles::users_by_role_id(ROLE1).is_empty()); + assert!(Roles::role_ids_by_space_id(SPACE1).is_empty()); + assert!(Roles::role_ids_by_user_in_space(User::Account(ACCOUNT2), SPACE1).is_empty()); + assert_eq!(Roles::next_role_id(), ROLE2); + }); +} + +#[test] +fn delete_role_should_work_with_a_few_roles() { + ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { + assert_ok!(_delete_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None // RoleId 1 + )); + + // Check whether storages are cleaned up + assert!(Roles::role_by_id(ROLE1).is_none()); + assert!(Roles::users_by_role_id(ROLE1).is_empty()); + assert_eq!(Roles::role_ids_by_space_id(SPACE1), vec![ROLE2]); + assert_eq!(Roles::role_ids_by_user_in_space(User::Account(ACCOUNT2), SPACE1), vec![ROLE2]); + assert_eq!(Roles::next_role_id(), ROLE3); + }); +} + +#[test] +fn delete_role_should_fail_with_role_not_found() { + ExtBuilder::build().execute_with(|| { + assert_noop!(_delete_default_role(), Error::::RoleNotFound); + }); +} + +#[test] +fn delete_role_should_fail_with_no_permission() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_role()); // RoleId 1 + assert_noop!( + _delete_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None // RoleId 1 + ), + Error::::NoPermissionToManageRoles + ); + }); +} + +#[test] +fn delete_role_should_fail_with_too_many_users_for_delete_role() { + ExtBuilder::build().execute_with(|| { + let mut users: Vec> = Vec::new(); + for account in 2..23 { + users.push(User::Account(account)); + } + + assert_ok!(_create_default_role()); // RoleId 1 + assert_ok!(_grant_role(None, None, Some(users))); // Grant RoleId 1 to ACCOUNT2-ACCOUNT20 + assert_noop!(_delete_default_role(), Error::::TooManyUsersToDeleteRole); + }); +} + +#[test] +fn delete_role_should_fail_with_a_few_roles_no_permission() { + ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { + assert_ok!(_delete_role(None, Some(ROLE2))); + assert_noop!( + _delete_role( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None // RoleId 1 + ), + Error::::NoPermissionToManageRoles + ); + }); +} diff --git a/pallets/roles/src/types.rs b/pallets/roles/src/types.rs new file mode 100644 index 0000000..e77e3ad --- /dev/null +++ b/pallets/roles/src/types.rs @@ -0,0 +1,43 @@ +use super::*; + +pub type RoleId = u64; + +pub const FIRST_ROLE_ID: u64 = 1; + +/// Information about a role's permissions, its' containing space, and its' content. +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +#[scale_info(skip_type_params(T))] +pub struct Role { + pub created: WhoAndWhenOf, + + /// Unique sequential identifier of a role. Examples of role ids: `1`, `2`, `3`, and so on. + pub id: RoleId, + + /// An id of a space that contains this role. + pub space_id: SpaceId, + + /// If `true` then the permissions associated with a given role will have no affect. + /// This is useful if you would like to temporarily disable permissions from a given role, + /// without removing the role from its' owners + pub disabled: bool, + + /// An optional block number at which this role will expire. If `expires_at` is `Some` + /// and the current block is greater or equal to its value, the permissions associated + /// with a given role will have no affect. + pub expires_at: Option, + + /// Content can optionally contain additional information associated with a role, + /// such as a name, description, and image for a role. This may be useful for end users. + pub content: Content, + + /// A set of permisions granted to owners of a particular role which are valid + /// only within the space containing this role + pub permissions: SpacePermissionSet, +} + +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +pub struct RoleUpdate { + pub disabled: Option, + pub content: Option, + pub permissions: Option, +} diff --git a/pallets/roles/src/weights.rs b/pallets/roles/src/weights.rs new file mode 100644 index 0000000..300b5ac --- /dev/null +++ b/pallets/roles/src/weights.rs @@ -0,0 +1,188 @@ + +//! Autogenerated weights for pallet_roles +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-02-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `benchmarks-ci`, CPU: `Intel(R) Xeon(R) Platinum 8280 CPU @ 2.70GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 + +// Executed Command: + // ./scripts/../target/release/subsocial-collator + // benchmark + // pallet + // --chain + // dev + // --execution + // wasm + // --wasm-execution + // Compiled + // --pallet + // pallet_roles + // --extrinsic + // * + // --steps + // 50 + // --repeat + // 20 + // --heap-pages + // 4096 + // --output + // pallets/roles/src/weights.rs + // --template + // ./.maintain/weight-template.hbs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(non_snake_case)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weight functions needed for pallet_roles. +pub trait WeightInfo { + fn create_role() -> Weight; + fn update_role() -> Weight; + fn delete_role(x: u32, ) -> Weight; + fn grant_role(x: u32, ) -> Weight; + fn revoke_role(x: u32, ) -> Weight; +} + +/// Weights for pallet_roles using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); + impl WeightInfo for SubstrateWeight { + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: Roles NextRoleId (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Roles RoleIdsBySpaceId (r:1 w:1) + // Storage: Roles RoleById (r:0 w:1) + fn create_role() -> Weight { + // Minimum execution time: 52_528 nanoseconds. + Weight::from_ref_time(53_688_000) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + } + // Storage: Roles RoleById (r:1 w:1) + // Storage: Spaces SpaceById (r:1 w:0) + fn update_role() -> Weight { + // Minimum execution time: 48_647 nanoseconds. + Weight::from_ref_time(50_219_000) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + // Storage: Roles RoleById (r:1 w:1) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: Roles UsersByRoleId (r:1 w:1) + // Storage: Roles RoleIdsBySpaceId (r:1 w:1) + // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) + /// The range of component `x` is `[0, 40]`. + fn delete_role(x: u32, ) -> Weight { + // Minimum execution time: 57_007 nanoseconds. + Weight::from_ref_time(64_783_236) + // Standard Error: 26_706 + .saturating_add(Weight::from_ref_time(8_701_651).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(x.into()))) + .saturating_add(T::DbWeight::get().writes(3)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(x.into()))) + } + // Storage: Roles RoleById (r:1 w:0) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: Roles UsersByRoleId (r:1 w:1) + // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) + /// The range of component `x` is `[1, 500]`. + fn grant_role(x: u32, ) -> Weight { + // Minimum execution time: 56_274 nanoseconds. + Weight::from_ref_time(56_612_000) + // Standard Error: 131_120 + .saturating_add(Weight::from_ref_time(21_272_680).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(x.into()))) + .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(x.into()))) + } + // Storage: Roles RoleById (r:1 w:0) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: Roles UsersByRoleId (r:1 w:1) + // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) + /// The range of component `x` is `[1, 500]`. + fn revoke_role(x: u32, ) -> Weight { + // Minimum execution time: 61_065 nanoseconds. + Weight::from_ref_time(61_492_000) + // Standard Error: 13_040 + .saturating_add(Weight::from_ref_time(9_647_540).saturating_mul(x.into())) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(x.into()))) + .saturating_add(T::DbWeight::get().writes(1)) + .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(x.into()))) + } + } + + // For backwards compatibility and tests + impl WeightInfo for () { + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: Roles NextRoleId (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Roles RoleIdsBySpaceId (r:1 w:1) + // Storage: Roles RoleById (r:0 w:1) + fn create_role() -> Weight { + // Minimum execution time: 52_528 nanoseconds. + Weight::from_ref_time(53_688_000) + .saturating_add(RocksDbWeight::get().reads(4)) + .saturating_add(RocksDbWeight::get().writes(3)) + } + // Storage: Roles RoleById (r:1 w:1) + // Storage: Spaces SpaceById (r:1 w:0) + fn update_role() -> Weight { + // Minimum execution time: 48_647 nanoseconds. + Weight::from_ref_time(50_219_000) + .saturating_add(RocksDbWeight::get().reads(2)) + .saturating_add(RocksDbWeight::get().writes(1)) + } + // Storage: Roles RoleById (r:1 w:1) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: Roles UsersByRoleId (r:1 w:1) + // Storage: Roles RoleIdsBySpaceId (r:1 w:1) + // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) + /// The range of component `x` is `[0, 40]`. + fn delete_role(x: u32, ) -> Weight { + // Minimum execution time: 57_007 nanoseconds. + Weight::from_ref_time(64_783_236) + // Standard Error: 26_706 + .saturating_add(Weight::from_ref_time(8_701_651).saturating_mul(x.into())) + .saturating_add(RocksDbWeight::get().reads(4)) + .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(x.into()))) + .saturating_add(RocksDbWeight::get().writes(3)) + .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(x.into()))) + } + // Storage: Roles RoleById (r:1 w:0) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: Roles UsersByRoleId (r:1 w:1) + // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) + /// The range of component `x` is `[1, 500]`. + fn grant_role(x: u32, ) -> Weight { + // Minimum execution time: 56_274 nanoseconds. + Weight::from_ref_time(56_612_000) + // Standard Error: 131_120 + .saturating_add(Weight::from_ref_time(21_272_680).saturating_mul(x.into())) + .saturating_add(RocksDbWeight::get().reads(3)) + .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(x.into()))) + .saturating_add(RocksDbWeight::get().writes(1)) + .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(x.into()))) + } + // Storage: Roles RoleById (r:1 w:0) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: Roles UsersByRoleId (r:1 w:1) + // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) + /// The range of component `x` is `[1, 500]`. + fn revoke_role(x: u32, ) -> Weight { + // Minimum execution time: 61_065 nanoseconds. + Weight::from_ref_time(61_492_000) + // Standard Error: 13_040 + .saturating_add(Weight::from_ref_time(9_647_540).saturating_mul(x.into())) + .saturating_add(RocksDbWeight::get().reads(3)) + .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(x.into()))) + .saturating_add(RocksDbWeight::get().writes(1)) + .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(x.into()))) + } + } diff --git a/pallets/space-follows/Cargo.toml b/pallets/space-follows/Cargo.toml new file mode 100644 index 0000000..5079cef --- /dev/null +++ b/pallets/space-follows/Cargo.toml @@ -0,0 +1,40 @@ +[package] +name = 'pallet-space-follows' +version = '0.1.7' +authors = ['DappForce '] +edition = '2021' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Pallet that allows to follow/unfollow spaces' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[features] +default = ['std'] +runtime-benchmarks = ["frame-benchmarking/runtime-benchmarks"] +std = [ + 'codec/std', + 'scale-info/std', + 'frame-benchmarking/std', + 'frame-support/std', + 'frame-system/std', + 'sp-std/std', + 'pallet-spaces/std', + 'subsocial-support/std', +] +try-runtime = ["frame-support/try-runtime"] + +[dependencies] +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } + +# Local depenpdencies +pallet-spaces = { default-features = false, path = '../spaces' } +subsocial-support = { default-features = false, path = '../support' } + +# Substrate dependencies +frame-benchmarking = { optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } +frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } diff --git a/pallets/space-follows/rpc/Cargo.toml b/pallets/space-follows/rpc/Cargo.toml new file mode 100644 index 0000000..f943590 --- /dev/null +++ b/pallets/space-follows/rpc/Cargo.toml @@ -0,0 +1,49 @@ +[package] +name = 'space-follows-rpc' +version = '0.7.3' +authors = ['DappForce '] +edition = '2018' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'RPC methods for the space-follows pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[dependencies.serde] +optional = true +features = ['derive'] +version = '1.0.119' + +[dependencies.codec] +default-features = false +features = ['derive'] +package = 'parity-scale-codec' +version = '2.0.0' + +[dependencies] +jsonrpc-core = '18.0.0' +jsonrpc-core-client = '18.0.0' +jsonrpc-derive = '18.0.0' + +# Local dependencies +pallet-utils = { default-features = false, path = '../../utils' } + +# Custom Runtime API +space-follows-runtime-api = { default-features = false, path = 'runtime-api' } + +# Substrate dependencies +sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-blockchain = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-rpc = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } + +[features] +default = ['std'] +std = [ + 'serde', + 'sp-runtime/std', + 'sp-api/std', + 'space-follows-runtime-api/std', + 'pallet-utils/std', +] diff --git a/pallets/space-follows/rpc/runtime-api/Cargo.toml b/pallets/space-follows/rpc/runtime-api/Cargo.toml new file mode 100644 index 0000000..49d3970 --- /dev/null +++ b/pallets/space-follows/rpc/runtime-api/Cargo.toml @@ -0,0 +1,41 @@ +[package] +name = 'space-follows-runtime-api' +version = '0.7.3' +authors = ['DappForce '] +edition = '2018' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Runtime API definition for the space-follows pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[dependencies.serde] +optional = true +features = ["derive"] +version = "1.0.119" + +[dependencies.codec] +default-features = false +features = ['derive'] +package = 'parity-scale-codec' +version = '2.0.0' + +[dependencies] +# Local dependencies +pallet-utils = { default-features = false, path = '../../../utils' } + +# Substrate dependencies +sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } + +[features] +default = ['std'] +std = [ + 'serde', + 'sp-api/std', + 'sp-std/std', + 'sp-runtime/std', + 'pallet-utils/std', +] diff --git a/pallets/space-follows/rpc/runtime-api/src/lib.rs b/pallets/space-follows/rpc/runtime-api/src/lib.rs new file mode 100644 index 0000000..1ce9870 --- /dev/null +++ b/pallets/space-follows/rpc/runtime-api/src/lib.rs @@ -0,0 +1,16 @@ +#![cfg_attr(not(feature = "std"), no_std)] + +use codec::Codec; +use sp_std::vec::Vec; + +use pallet_utils::SpaceId; + +sp_api::decl_runtime_apis! { + pub trait SpaceFollowsApi where + AccountId: Codec + { + fn get_space_ids_followed_by_account(account: AccountId) -> Vec; + + fn filter_followed_space_ids(account: AccountId, space_ids: Vec) -> Vec; + } +} diff --git a/pallets/space-follows/rpc/src/lib.rs b/pallets/space-follows/rpc/src/lib.rs new file mode 100644 index 0000000..8149233 --- /dev/null +++ b/pallets/space-follows/rpc/src/lib.rs @@ -0,0 +1,76 @@ +use std::sync::Arc; +use codec::Codec; +use sp_blockchain::HeaderBackend; +use sp_runtime::{generic::BlockId, traits::Block as BlockT}; +use jsonrpc_core::Result; +use jsonrpc_derive::rpc; +use sp_api::ProvideRuntimeApi; + +use pallet_utils::{SpaceId, rpc::map_rpc_error}; +pub use space_follows_runtime_api::SpaceFollowsApi as SpaceFollowsRuntimeApi; + +#[rpc] +pub trait SpaceFollowsApi { + #[rpc(name = "spaceFollows_getSpaceIdsFollowedByAccount")] + fn get_space_ids_followed_by_account( + &self, + at: Option, + account: AccountId, + ) -> Result>; + + #[rpc(name = "spaceFollows_filterFollowedSpaceIds")] + fn filter_followed_space_ids( + &self, + at: Option, + account: AccountId, + space_ids: Vec, + ) -> Result>; +} + +pub struct SpaceFollows { + client: Arc, + _marker: std::marker::PhantomData, +} + +impl SpaceFollows { + pub fn new(client: Arc) -> Self { + Self { + client, + _marker: Default::default(), + } + } +} + +impl SpaceFollowsApi<::Hash, AccountId> + for SpaceFollows +where + Block: BlockT, + AccountId: Codec, + C: Send + Sync + 'static + ProvideRuntimeApi + HeaderBackend, + C::Api: SpaceFollowsRuntimeApi, +{ + fn get_space_ids_followed_by_account( + &self, + at: Option<::Hash>, + account: AccountId, + ) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_space_ids_followed_by_account(&at, account); + runtime_api_result.map_err(map_rpc_error) + } + + fn filter_followed_space_ids( + &self, + at: Option<::Hash>, + account: AccountId, + space_ids: Vec, + ) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.filter_followed_space_ids(&at, account, space_ids); + runtime_api_result.map_err(map_rpc_error) + } +} diff --git a/pallets/space-follows/src/benchmarking.rs b/pallets/space-follows/src/benchmarking.rs new file mode 100644 index 0000000..cb9d664 --- /dev/null +++ b/pallets/space-follows/src/benchmarking.rs @@ -0,0 +1,52 @@ +//! Space follows pallet benchmarking. + +#![cfg(feature = "runtime-benchmarks")] + +use super::*; +use frame_benchmarking::{account, benchmarks}; +use frame_support::{dispatch::DispatchError, ensure}; +use frame_system::RawOrigin; +use pallet_spaces::types::Space; +use subsocial_support::Content; + +fn create_dummy_space( + origin: RawOrigin, +) -> Result, DispatchError> { + let space_id = pallet_spaces::NextSpaceId::::get(); + + pallet_spaces::Pallet::::create_space(origin.clone().into(), Content::None, None)?; + + let space = pallet_spaces::SpaceById::::get(space_id) + .ok_or(DispatchError::Other("Space not found"))?; + + Ok(space) +} + +benchmarks! { + + follow_space { + let space_owner_origin = RawOrigin::Signed(account::("SpaceOwner", 2, 0)); + let space_follower = account::("SpaceFollower", 1, 0); + + let space = create_dummy_space::(space_owner_origin.clone())?; + }: _(RawOrigin::Signed(space_follower.clone()), space.id) + verify { + ensure!(SpaceFollowers::::get(space.id).contains(&space_follower), "SpaceFollowers was not updated"); + ensure!(SpaceFollowedByAccount::::get(&(space_follower.clone(), space.id)), "SpaceFollowedByAccount was not updated"); + ensure!(SpacesFollowedByAccount::::get(&space_follower).contains(&space.id), "SpacesFollowedByAccount was not updated"); + } + + unfollow_space { + let space_owner_origin = RawOrigin::Signed(account::("SpaceOwner", 2, 0)); + let space_follower = account::("SpaceFollower", 1, 0); + + let space = create_dummy_space::(space_owner_origin.clone())?; + Pallet::::follow_space(RawOrigin::Signed(space_follower.clone()).into(),space.id)?; + + }: _(RawOrigin::Signed(space_follower.clone()), space.id) + verify { + ensure!(!SpaceFollowers::::get(space.id).contains(&space_follower), "SpaceFollowers was not updated"); + ensure!(!SpaceFollowedByAccount::::get(&(space_follower.clone(), space.id)), "SpaceFollowedByAccount was not updated"); + ensure!(!SpacesFollowedByAccount::::get(&space_follower).contains(&space.id), "SpacesFollowedByAccount was not updated"); + } +} diff --git a/pallets/space-follows/src/lib.rs b/pallets/space-follows/src/lib.rs new file mode 100644 index 0000000..95a3f62 --- /dev/null +++ b/pallets/space-follows/src/lib.rs @@ -0,0 +1,170 @@ +#![cfg_attr(not(feature = "std"), no_std)] + +pub use pallet::*; + +use frame_support::dispatch::DispatchResult; + +use pallet_spaces::Pallet as Spaces; + +#[cfg(feature = "runtime-benchmarks")] +mod benchmarking; +pub mod weights; + +// pub mod rpc; + +#[frame_support::pallet] +pub mod pallet { + use super::*; + + use crate::weights::WeightInfo; + use frame_support::pallet_prelude::*; + use frame_system::pallet_prelude::*; + use sp_std::vec::Vec; + use subsocial_support::{ + remove_from_vec, + traits::{IsAccountBlocked, SpaceFollowsProvider}, + ModerationError, SpaceId, + }; + + #[pallet::config] + pub trait Config: frame_system::Config + pallet_spaces::Config { + /// The overarching event type. + type RuntimeEvent: From> + IsType<::RuntimeEvent>; + + type WeightInfo: WeightInfo; + } + + #[pallet::pallet] + #[pallet::generate_store(pub(super) trait Store)] + #[pallet::without_storage_info] + pub struct Pallet(_); + + #[pallet::error] + pub enum Error { + /// Account is already a space follower. + AlreadySpaceFollower, + /// Account is not a space follower. + NotSpaceFollower, + /// Not allowed to follow a hidden space. + CannotFollowHiddenSpace, + } + + #[pallet::storage] + #[pallet::getter(fn space_followers)] + pub type SpaceFollowers = + StorageMap<_, Twox64Concat, SpaceId, Vec, ValueQuery>; + + #[pallet::storage] + #[pallet::getter(fn space_followed_by_account)] + pub type SpaceFollowedByAccount = + StorageMap<_, Blake2_128Concat, (T::AccountId, SpaceId), bool, ValueQuery>; + + #[pallet::storage] + #[pallet::getter(fn spaces_followed_by_account)] + pub type SpacesFollowedByAccount = + StorageMap<_, Twox64Concat, T::AccountId, Vec, ValueQuery>; + + #[pallet::event] + #[pallet::generate_deposit(pub(super) fn deposit_event)] + pub enum Event { + SpaceFollowed { follower: T::AccountId, space_id: SpaceId }, + SpaceUnfollowed { follower: T::AccountId, space_id: SpaceId }, + } + + #[pallet::call] + impl Pallet { + #[pallet::call_index(0)] + #[pallet::weight(::WeightInfo::follow_space())] + pub fn follow_space(origin: OriginFor, space_id: SpaceId) -> DispatchResult { + let follower = ensure_signed(origin)?; + + ensure!( + !Self::space_followed_by_account((follower.clone(), space_id)), + Error::::AlreadySpaceFollower + ); + + let space = Spaces::::require_space(space_id)?; + ensure!(!space.hidden, Error::::CannotFollowHiddenSpace); + + ensure!( + T::IsAccountBlocked::is_allowed_account(follower.clone(), space.id), + ModerationError::AccountIsBlocked + ); + + Self::add_space_follower(follower, space_id); + + Ok(()) + } + + #[pallet::call_index(1)] + #[pallet::weight(::WeightInfo::unfollow_space())] + pub fn unfollow_space(origin: OriginFor, space_id: SpaceId) -> DispatchResult { + let follower = ensure_signed(origin)?; + + Spaces::::ensure_space_exists(space_id)?; + + ensure!( + Self::space_followed_by_account((follower.clone(), space_id)), + Error::::NotSpaceFollower + ); + + Self::remove_space_follower(follower, space_id) + } + + #[pallet::call_index(2)] + #[pallet::weight(( + Weight::from_ref_time(100_000) + T::DbWeight::get().reads_writes(3, 4), + DispatchClass::Operational, + Pays::Yes, + ))] + pub fn force_follow_space( + origin: OriginFor, + follower: T::AccountId, + space_id: SpaceId, + ) -> DispatchResultWithPostInfo { + ensure_root(origin)?; + + ensure!( + !Self::space_followed_by_account((follower.clone(), space_id)), + Error::::AlreadySpaceFollower + ); + + Self::add_space_follower(follower, space_id); + + Ok(Pays::No.into()) + } + } + + impl Pallet { + fn add_space_follower(follower: T::AccountId, space_id: SpaceId) { + SpaceFollowers::::mutate(space_id, |followers| followers.push(follower.clone())); + SpaceFollowedByAccount::::insert((follower.clone(), space_id), true); + SpacesFollowedByAccount::::mutate(follower.clone(), |space_ids| { + space_ids.push(space_id) + }); + + Self::deposit_event(Event::SpaceFollowed { follower, space_id }); + } + + pub fn remove_space_follower(follower: T::AccountId, space_id: SpaceId) -> DispatchResult { + SpacesFollowedByAccount::::mutate(follower.clone(), |space_ids| { + remove_from_vec(space_ids, space_id) + }); + SpaceFollowers::::mutate(space_id, |account_ids| { + remove_from_vec(account_ids, follower.clone()) + }); + SpaceFollowedByAccount::::remove((follower.clone(), space_id)); + + Self::deposit_event(Event::SpaceUnfollowed { follower, space_id }); + Ok(()) + } + } + + impl SpaceFollowsProvider for Pallet { + type AccountId = T::AccountId; + + fn is_space_follower(account: Self::AccountId, space_id: SpaceId) -> bool { + Pallet::::space_followed_by_account((account, space_id)) + } + } +} diff --git a/pallets/space-follows/src/rpc.rs b/pallets/space-follows/src/rpc.rs new file mode 100644 index 0000000..f82c979 --- /dev/null +++ b/pallets/space-follows/src/rpc.rs @@ -0,0 +1,17 @@ +use sp_std::prelude::*; + +use pallet_utils::SpaceId; + +use crate::{Config, Pallet}; + +impl Pallet { + pub fn get_space_ids_followed_by_account(account: T::AccountId) -> Vec { + Self::spaces_followed_by_account(account) + } + + pub fn filter_followed_space_ids(account: T::AccountId, space_ids: Vec) -> Vec { + space_ids.iter() + .filter(|space_id| Self::space_followed_by_account((&account, space_id))) + .cloned().collect() + } +} \ No newline at end of file diff --git a/pallets/space-follows/src/weights.rs b/pallets/space-follows/src/weights.rs new file mode 100644 index 0000000..b725216 --- /dev/null +++ b/pallets/space-follows/src/weights.rs @@ -0,0 +1,95 @@ + +//! Autogenerated weights for pallet_space_follows +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-02-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `benchmarks-ci`, CPU: `Intel(R) Xeon(R) Platinum 8280 CPU @ 2.70GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 + +// Executed Command: + // ./scripts/../target/release/subsocial-collator + // benchmark + // pallet + // --chain + // dev + // --execution + // wasm + // --wasm-execution + // Compiled + // --pallet + // pallet_space_follows + // --extrinsic + // * + // --steps + // 50 + // --repeat + // 20 + // --heap-pages + // 4096 + // --output + // pallets/space-follows/src/weights.rs + // --template + // ./.maintain/weight-template.hbs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(non_snake_case)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weight functions needed for pallet_space_follows. +pub trait WeightInfo { + fn follow_space() -> Weight; + fn unfollow_space() -> Weight; +} + +/// Weights for pallet_space_follows using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); + impl WeightInfo for SubstrateWeight { + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:1) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowers (r:1 w:1) + // Storage: SpaceFollows SpacesFollowedByAccount (r:1 w:1) + fn follow_space() -> Weight { + // Minimum execution time: 48_140 nanoseconds. + Weight::from_ref_time(48_862_000) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + } + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:1) + // Storage: SpaceFollows SpacesFollowedByAccount (r:1 w:1) + // Storage: SpaceFollows SpaceFollowers (r:1 w:1) + fn unfollow_space() -> Weight { + // Minimum execution time: 55_112 nanoseconds. + Weight::from_ref_time(55_868_000) + .saturating_add(T::DbWeight::get().reads(4)) + .saturating_add(T::DbWeight::get().writes(3)) + } + } + + // For backwards compatibility and tests + impl WeightInfo for () { + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:1) + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowers (r:1 w:1) + // Storage: SpaceFollows SpacesFollowedByAccount (r:1 w:1) + fn follow_space() -> Weight { + // Minimum execution time: 48_140 nanoseconds. + Weight::from_ref_time(48_862_000) + .saturating_add(RocksDbWeight::get().reads(4)) + .saturating_add(RocksDbWeight::get().writes(3)) + } + // Storage: Spaces SpaceById (r:1 w:0) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:1) + // Storage: SpaceFollows SpacesFollowedByAccount (r:1 w:1) + // Storage: SpaceFollows SpaceFollowers (r:1 w:1) + fn unfollow_space() -> Weight { + // Minimum execution time: 55_112 nanoseconds. + Weight::from_ref_time(55_868_000) + .saturating_add(RocksDbWeight::get().reads(4)) + .saturating_add(RocksDbWeight::get().writes(3)) + } + } diff --git a/pallets/space-follows/tests/Cargo.toml b/pallets/space-follows/tests/Cargo.toml new file mode 100644 index 0000000..8eac0c0 --- /dev/null +++ b/pallets/space-follows/tests/Cargo.toml @@ -0,0 +1,58 @@ +[package] +name = 'pallet-space-follows-tests' +version = '0.1.7' +authors = ['DappForce '] +edition = '2021' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Tests for Space Follows pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } + +# Local dependencies +subsocial-support = { default-features = false, path = '../../support' } +pallet-permissions = { default-features = false, path = '../../permissions' } +pallet-space-follows = { default-features = false, path = '..' } + +# Substrate dependencies +pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } + +[dev-dependencies] +sp-core = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-io = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } +pallet-roles = { default-features = false, path = '../../roles' } +pallet-profiles = { default-features = false, path = '../../profiles' } +pallet-posts = { default-features = false, path = '../../posts' } +pallet-spaces = { default-features = false, path = '../../spaces' } + +[features] +default = ['std'] +std = [ + 'codec/std', + 'scale-info/std', + 'pallet-timestamp/std', + 'frame-support/std', + 'frame-system/std', + 'sp-runtime/std', + 'sp-std/std', + 'pallet-permissions/std', + 'pallet-balances/std', + 'pallet-roles/std', + 'pallet-space-follows/std', + 'pallet-profiles/std', + 'pallet-posts/std', +] +try-runtime = ["frame-support/try-runtime"] diff --git a/pallets/space-follows/tests/src/lib.rs b/pallets/space-follows/tests/src/lib.rs new file mode 100644 index 0000000..71dc193 --- /dev/null +++ b/pallets/space-follows/tests/src/lib.rs @@ -0,0 +1,6 @@ +#[cfg(test)] +mod mock; +#[cfg(test)] +mod tests; +#[cfg(test)] +mod tests_utils; diff --git a/pallets/space-follows/tests/src/mock.rs b/pallets/space-follows/tests/src/mock.rs new file mode 100644 index 0000000..c6559e5 --- /dev/null +++ b/pallets/space-follows/tests/src/mock.rs @@ -0,0 +1,122 @@ +use frame_support::{pallet_prelude::ConstU32, parameter_types, traits::Everything}; +use sp_core::H256; +use sp_runtime::{ + testing::Header, + traits::{BlakeTwo256, IdentityLookup}, +}; +use sp_std::convert::{TryFrom, TryInto}; + +type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; +type Block = frame_system::mocking::MockBlock; + +frame_support::construct_runtime!( + pub enum Test where + Block = Block, + NodeBlock = Block, + UncheckedExtrinsic = UncheckedExtrinsic, + { + System: frame_system, + Timestamp: pallet_timestamp, + Balances: pallet_balances, + Permissions: pallet_permissions, + Roles: pallet_roles, + SpaceFollows: pallet_space_follows, + Spaces: pallet_spaces, + } +); + +pub(super) type AccountId = u64; +pub(super) type Balance = u64; +pub(super) type BlockNumber = u64; + +parameter_types! { + pub const BlockHashCount: u64 = 250; + pub const SS58Prefix: u8 = 42; +} + +impl frame_system::Config for Test { + type BaseCallFilter = Everything; + type BlockWeights = (); + type BlockLength = (); + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + type Index = u64; + type BlockNumber = BlockNumber; + type Hash = H256; + type Hashing = BlakeTwo256; + type AccountId = AccountId; + type Lookup = IdentityLookup; + type Header = Header; + type RuntimeEvent = RuntimeEvent; + type BlockHashCount = BlockHashCount; + type DbWeight = (); + type Version = (); + type PalletInfo = PalletInfo; + type AccountData = pallet_balances::AccountData; + type OnNewAccount = (); + type OnKilledAccount = (); + type SystemWeightInfo = (); + type SS58Prefix = SS58Prefix; + type OnSetCode = (); + type MaxConsumers = frame_support::traits::ConstU32<16>; +} + +parameter_types! { + pub const MinimumPeriod: u64 = 5; +} + +impl pallet_timestamp::Config for Test { + type Moment = u64; + type OnTimestampSet = (); + type MinimumPeriod = MinimumPeriod; + type WeightInfo = (); +} + +parameter_types! { + pub const ExistentialDeposit: u64 = 1; +} + +impl pallet_balances::Config for Test { + type Balance = Balance; + type DustRemoval = (); + type RuntimeEvent = RuntimeEvent; + type ExistentialDeposit = ExistentialDeposit; + type AccountStore = System; + type WeightInfo = (); + type MaxLocks = (); + type MaxReserves = (); + type ReserveIdentifier = (); +} + +impl pallet_permissions::Config for Test { + type DefaultSpacePermissions = pallet_permissions::default_permissions::DefaultSpacePermissions; +} + +parameter_types! { + pub const MaxUsersToProcessPerDeleteRole: u16 = 40; +} + +impl pallet_roles::Config for Test { + type RuntimeEvent = RuntimeEvent; + type MaxUsersToProcessPerDeleteRole = MaxUsersToProcessPerDeleteRole; + type SpacePermissionsProvider = Spaces; + type SpaceFollows = SpaceFollows; + type IsAccountBlocked = (); + type IsContentBlocked = (); + type WeightInfo = (); +} + +impl pallet_spaces::Config for Test { + type RuntimeEvent = RuntimeEvent; + type Roles = Roles; + type SpaceFollows = SpaceFollows; + type IsAccountBlocked = (); + type IsContentBlocked = (); + type MaxSpacesPerAccount = ConstU32<100>; + type WeightInfo = (); +} + +impl pallet_space_follows::Config for Test { + type RuntimeEvent = RuntimeEvent; + type WeightInfo = (); +} diff --git a/pallets/space-follows/tests/src/tests.rs b/pallets/space-follows/tests/src/tests.rs new file mode 100644 index 0000000..8764de8 --- /dev/null +++ b/pallets/space-follows/tests/src/tests.rs @@ -0,0 +1,65 @@ +use crate::{mock::*, tests_utils::*}; +use frame_support::{assert_noop, assert_ok}; +use pallet_space_follows::Error as SpaceFollowsError; +use pallet_spaces::Error as SpacesError; + +#[test] +fn follow_space_should_work() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!(_default_follow_space()); // Follow SpaceId 1 by ACCOUNT2 + + assert_eq!(SpaceFollows::spaces_followed_by_account(ACCOUNT2), vec![SPACE1]); + assert_eq!(SpaceFollows::space_followers(SPACE1), vec![ACCOUNT2]); + assert!(SpaceFollows::space_followed_by_account((ACCOUNT2, SPACE1))); + }); +} + +#[test] +fn follow_space_should_fail_when_space_not_found() { + ExtBuilder::build().execute_with(|| { + assert_noop!(_default_follow_space(), SpacesError::::SpaceNotFound); + }); +} + +#[test] +fn follow_space_should_fail_when_account_is_already_space_follower() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!(_default_follow_space()); // Follow SpaceId 1 by ACCOUNT2 + + assert_noop!(_default_follow_space(), SpaceFollowsError::::AlreadySpaceFollower); + }); +} + +#[test] +fn follow_space_should_fail_when_trying_to_follow_hidden_space() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!(_update_space(None, None, Some(space_update(None, Some(true))))); + + assert_noop!(_default_follow_space(), SpaceFollowsError::::CannotFollowHiddenSpace); + }); +} + +#[test] +fn unfollow_space_should_work() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!(_default_follow_space()); + // Follow SpaceId 1 by ACCOUNT2 + assert_ok!(_default_unfollow_space()); + + assert!(SpaceFollows::spaces_followed_by_account(ACCOUNT2).is_empty()); + assert!(SpaceFollows::space_followers(SPACE1).is_empty()); + }); +} +#[test] +fn unfollow_space_should_fail_when_space_not_found() { + ExtBuilder::build_with_space_follow_no_space().execute_with(|| { + assert_noop!(_default_unfollow_space(), SpacesError::::SpaceNotFound); + }); +} + +#[test] +fn unfollow_space_should_fail_when_account_is_not_space_follower_yet() { + ExtBuilder::build_with_space().execute_with(|| { + assert_noop!(_default_unfollow_space(), SpaceFollowsError::::NotSpaceFollower); + }); +} diff --git a/pallets/space-follows/tests/src/tests_utils.rs b/pallets/space-follows/tests/src/tests_utils.rs new file mode 100644 index 0000000..eea6f25 --- /dev/null +++ b/pallets/space-follows/tests/src/tests_utils.rs @@ -0,0 +1,134 @@ +use frame_support::{assert_ok, pallet_prelude::*}; +use pallet_permissions::SpacePermissions; +use pallet_spaces::{types::SpaceUpdate, SpaceById}; +use sp_core::storage::Storage; +use sp_io::TestExternalities; +use subsocial_support::{Content, SpaceId}; + +use crate::mock::*; + +////// Ext Builder + +pub struct ExtBuilder; + +impl ExtBuilder { + fn configure_storages(storage: &mut Storage) { + let mut accounts = Vec::new(); + for account in ACCOUNT1..=ACCOUNT3 { + accounts.push(account); + } + + let _ = pallet_balances::GenesisConfig:: { + balances: accounts.iter().cloned().map(|k| (k, 100)).collect(), + } + .assimilate_storage(storage); + } + + /// Default ext configuration with BlockNumber 1 + pub fn build() -> TestExternalities { + let mut storage = frame_system::GenesisConfig::default().build_storage::().unwrap(); + + Self::configure_storages(&mut storage); + + let mut ext = TestExternalities::from(storage); + ext.execute_with(|| System::set_block_number(1)); + + ext + } + + fn add_default_space() { + assert_ok!(_create_default_space()); + } + + /// Custom ext configuration with SpaceId 1 and BlockNumber 1 + pub fn build_with_space() -> TestExternalities { + let mut ext = Self::build(); + ext.execute_with(Self::add_default_space); + ext + } + + /// Custom ext configuration with space follow without Space + pub fn build_with_space_follow_no_space() -> TestExternalities { + let mut ext = Self::build_with_space(); + + ext.execute_with(|| { + assert_ok!(_default_follow_space()); + >::remove(SPACE1); + }); + + ext + } +} + +////// Consts + +pub(crate) const ACCOUNT1: AccountId = 1; +pub(crate) const ACCOUNT2: AccountId = 2; +pub(crate) const ACCOUNT3: AccountId = 3; + +pub(crate) const SPACE1: SpaceId = 1001; + +///////////// Space Utils + +pub(crate) fn space_content_ipfs() -> Content { + Content::IPFS(b"bafyreib3mgbou4xln42qqcgj6qlt3cif35x4ribisxgq7unhpun525l54e".to_vec()) +} + +pub(crate) fn space_update(content: Option, hidden: Option) -> SpaceUpdate { + SpaceUpdate { content, hidden, permissions: None } +} + +pub(crate) fn _create_default_space() -> DispatchResult { + _create_space(None, None, None, None) +} + +pub(crate) fn _create_space( + origin: Option, + // FIXME: we don't have handles anymore + _handle: Option>>, + content: Option, + permissions: Option>, +) -> DispatchResult { + Spaces::create_space( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + content.unwrap_or_else(space_content_ipfs), + permissions.unwrap_or_default(), + ) +} + + +pub(crate) fn _update_space( + origin: Option, + space_id: Option, + update: Option, +) -> DispatchResult { + Spaces::update_space( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + space_id.unwrap_or(SPACE1), + update.unwrap_or_else(|| space_update(None, None)), + ) +} + +//// Space follows utils + +pub(crate) fn _default_follow_space() -> DispatchResult { + _follow_space(None, None) +} + +pub(crate) fn _follow_space(origin: Option, space_id: Option) -> DispatchResult { + SpaceFollows::follow_space( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT2)), + space_id.unwrap_or(SPACE1), + ) +} + +pub(crate) fn _default_unfollow_space() -> DispatchResult { + _unfollow_space(None, None) +} + +pub(crate) fn _unfollow_space(origin: Option, space_id: Option) -> DispatchResult { + SpaceFollows::unfollow_space( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT2)), + space_id.unwrap_or(SPACE1), + ) +} diff --git a/pallets/spaces/Cargo.toml b/pallets/spaces/Cargo.toml new file mode 100644 index 0000000..0cc02c2 --- /dev/null +++ b/pallets/spaces/Cargo.toml @@ -0,0 +1,48 @@ +[package] +name = 'pallet-spaces' +version = '0.1.7' +authors = ['DappForce '] +edition = '2021' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Space management pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +impl-trait-for-tuples = '0.2.2' +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } + +# Local dependencies +subsocial-support = { default-features = false, path = '../support' } +pallet-permissions = { default-features = false, path = '../permissions' } + +# Substrate dependencies +pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-benchmarking = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false, optional = true } +frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } + +[features] +default = ['std'] +runtime-benchmarks = ['frame-benchmarking/runtime-benchmarks'] +std = [ + 'codec/std', + 'scale-info/std', + 'pallet-timestamp/std', + 'frame-benchmarking/std', + 'frame-support/std', + 'frame-system/std', + 'sp-runtime/std', + 'sp-std/std', + 'subsocial-support/std', + 'pallet-permissions/std' +] +try-runtime = ['frame-support/try-runtime'] diff --git a/pallets/spaces/rpc/Cargo.toml b/pallets/spaces/rpc/Cargo.toml new file mode 100644 index 0000000..e302671 --- /dev/null +++ b/pallets/spaces/rpc/Cargo.toml @@ -0,0 +1,51 @@ +[package] +name = 'spaces-rpc' +version = '0.7.3' +authors = ['DappForce '] +edition = '2018' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'RPC methods for the spaces pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[dependencies.serde] +optional = true +features = ['derive'] +version = '1.0.119' + +[dependencies.codec] +default-features = false +features = ['derive'] +package = 'parity-scale-codec' +version = '2.0.0' + +[dependencies] +jsonrpc-core = '18.0.0' +jsonrpc-core-client = '18.0.0' +jsonrpc-derive = '18.0.0' + +# Local dependencies +pallet-spaces = { default-features = false, path = '..' } +pallet-utils = { default-features = false, path = '../../utils' } + +# Custom Runtime API +spaces-runtime-api = { default-features = false, path = 'runtime-api' } + +# Substrate dependencies +sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-blockchain = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-rpc = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } + +[features] +default = ['std'] +std = [ + 'serde', + 'sp-runtime/std', + 'sp-api/std', + 'spaces-runtime-api/std', + 'pallet-spaces/std', + 'pallet-utils/std' +] diff --git a/pallets/spaces/rpc/runtime-api/Cargo.toml b/pallets/spaces/rpc/runtime-api/Cargo.toml new file mode 100644 index 0000000..0b7cefb --- /dev/null +++ b/pallets/spaces/rpc/runtime-api/Cargo.toml @@ -0,0 +1,43 @@ +[package] +name = 'spaces-runtime-api' +version = '0.7.3' +authors = ['DappForce '] +edition = '2018' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Runtime API definition for the spaces pallet' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[dependencies.serde] +optional = true +features = ["derive"] +version = "1.0.119" + +[dependencies.codec] +default-features = false +features = ['derive'] +package = 'parity-scale-codec' +version = '2.0.0' + +[dependencies] +# Local dependencies +pallet-spaces = { default-features = false, path = '../..' } +pallet-utils = { default-features = false, path = '../../../utils' } + +# Substrate dependencies +sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } + +[features] +default = ['std'] +std = [ + 'serde', + 'sp-api/std', + 'sp-std/std', + 'sp-runtime/std', + 'pallet-spaces/std', + 'pallet-utils/std' +] diff --git a/pallets/spaces/rpc/runtime-api/src/lib.rs b/pallets/spaces/rpc/runtime-api/src/lib.rs new file mode 100644 index 0000000..bfa02e6 --- /dev/null +++ b/pallets/spaces/rpc/runtime-api/src/lib.rs @@ -0,0 +1,32 @@ +#![cfg_attr(not(feature = "std"), no_std)] + +use codec::Codec; +use sp_std::vec::Vec; + +use pallet_spaces::rpc::FlatSpace; +use pallet_utils::SpaceId; + +sp_api::decl_runtime_apis! { + pub trait SpacesApi where + AccountId: Codec, + BlockNumber: Codec + { + fn get_next_space_id() -> SpaceId; + + fn get_spaces(start_id: u64, limit: u64) -> Vec>; + + fn get_spaces_by_ids(space_ids: Vec) -> Vec>; + + fn get_public_spaces(start_id: u64, limit: u64) -> Vec>; + + fn get_unlisted_spaces(start_id: u64, limit: u64) -> Vec>; + + fn get_public_space_ids_by_owner(owner: AccountId) -> Vec; + + fn get_unlisted_space_ids_by_owner(owner: AccountId) -> Vec; + + fn get_space_by_handle(handle: Vec) -> Option>; + + fn get_space_id_by_handle(handle: Vec) -> Option; + } +} diff --git a/pallets/spaces/rpc/src/lib.rs b/pallets/spaces/rpc/src/lib.rs new file mode 100644 index 0000000..af68f3e --- /dev/null +++ b/pallets/spaces/rpc/src/lib.rs @@ -0,0 +1,195 @@ +use std::sync::Arc; +use codec::Codec; +use sp_blockchain::HeaderBackend; +use sp_runtime::{generic::BlockId, traits::Block as BlockT}; +use jsonrpc_core::Result; +use jsonrpc_derive::rpc; +use sp_api::ProvideRuntimeApi; + +use pallet_spaces::rpc::FlatSpace; +use pallet_utils::{SpaceId, rpc::map_rpc_error}; +pub use spaces_runtime_api::SpacesApi as SpacesRuntimeApi; + +#[rpc] +pub trait SpacesApi { + #[rpc(name = "spaces_getSpaces")] + fn get_spaces( + &self, + at: Option, + start_id: u64, + limit: u64, + ) -> Result>>; + + #[rpc(name = "spaces_getSpacesByIds")] + fn get_spaces_by_ids( + &self, + at: Option, + space_ids: Vec, + ) -> Result>>; + + #[rpc(name = "spaces_getPublicSpaces")] + fn get_public_spaces( + &self, + at: Option, + start_id: u64, + limit: u64, + ) -> Result>>; + + #[rpc(name = "spaces_getUnlistedSpaces")] + fn get_unlisted_spaces( + &self, + at: Option, + start_id: u64, + limit: u64, + ) -> Result>>; + + #[rpc(name = "spaces_getSpaceIdByHandle")] + fn get_space_id_by_handle( + &self, + at: Option, + handle: Vec, + ) -> Result>; + + #[rpc(name = "spaces_getSpaceByHandle")] + fn get_space_by_handle( + &self, + at: Option, + handle: Vec, + ) -> Result>>; + + #[rpc(name = "spaces_getPublicSpaceIdsByOwner")] + fn get_public_space_ids_by_owner( + &self, + at: Option, + owner: AccountId, + ) -> Result>; + + #[rpc(name = "spaces_getUnlistedSpaceIdsByOwner")] + fn get_unlisted_space_ids_by_owner( + &self, + at: Option, + owner: AccountId, + ) -> Result>; + + #[rpc(name = "spaces_nextSpaceId")] + fn get_next_space_id(&self, at: Option) -> Result; +} + +pub struct Spaces { + client: Arc, + _marker: std::marker::PhantomData, +} + +impl Spaces { + pub fn new(client: Arc) -> Self { + Self { + client, + _marker: Default::default(), + } + } +} + +impl SpacesApi<::Hash, AccountId, BlockNumber> + for Spaces +where + Block: BlockT, + AccountId: Codec, + BlockNumber: Codec, + C: Send + Sync + 'static + ProvideRuntimeApi + HeaderBackend, + C::Api: SpacesRuntimeApi, +{ + fn get_spaces( + &self, + at: Option<::Hash>, + start_id: u64, + limit: u64, + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_spaces(&at, start_id, limit); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_spaces_by_ids( + &self, + at: Option<::Hash>, + space_ids: Vec, + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_spaces_by_ids(&at, space_ids); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_public_spaces( + &self, + at: Option<::Hash>, + start_id: u64, + limit: u64, + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_public_spaces(&at, start_id, limit); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_unlisted_spaces( + &self, + at: Option<::Hash>, + start_id: u64, + limit: u64, + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_unlisted_spaces(&at, start_id, limit); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_space_id_by_handle(&self, at: Option<::Hash>, handle: Vec) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_space_id_by_handle(&at, handle); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_space_by_handle( + &self, + at: Option<::Hash>, + handle: Vec, + ) -> Result>> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_space_by_handle(&at, handle); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_public_space_ids_by_owner(&self, at: Option<::Hash>, owner: AccountId) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_public_space_ids_by_owner(&at, owner); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_unlisted_space_ids_by_owner(&self, at: Option<::Hash>, owner: AccountId) -> Result> { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_unlisted_space_ids_by_owner(&at, owner); + runtime_api_result.map_err(map_rpc_error) + } + + fn get_next_space_id(&self, at: Option<::Hash>) -> Result { + let api = self.client.runtime_api(); + let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); + + let runtime_api_result = api.get_next_space_id(&at); + runtime_api_result.map_err(map_rpc_error) + } +} diff --git a/pallets/spaces/src/benchmarking.rs b/pallets/spaces/src/benchmarking.rs new file mode 100644 index 0000000..f37f714 --- /dev/null +++ b/pallets/spaces/src/benchmarking.rs @@ -0,0 +1,57 @@ +//! Spaces pallet benchmarking. + +use frame_benchmarking::{benchmarks, whitelisted_caller}; +use frame_support::{assert_ok, ensure, pallet_prelude::Get}; +use frame_system::RawOrigin; + +use crate::{types::*, Config}; + +use super::*; + +fn dummy_space_content() -> Content { + subsocial_support::mock_functions::valid_content_ipfs() +} + +fn create_dummy_space(caller: T::AccountId) -> Space { + assert_ok!(Pallet::::create_space(RawOrigin::Signed(caller).into(), Content::None, None)); + let id = Pallet::::next_space_id() - 1; + + SpaceById::::get(id).expect("qed; space should exist") +} + +benchmarks! { + create_space { + let caller = whitelisted_caller::(); + + let parent_space = create_dummy_space::(caller.clone()); + let new_space_id = NextSpaceId::::get(); + + let content = dummy_space_content(); + let permissions_opt = None; + }: _(RawOrigin::Signed(caller), content, permissions_opt) + verify { + ensure!(SpaceById::::get(new_space_id).is_some(), "Created space should exist"); + } + + update_space { + let caller = whitelisted_caller::(); + + let space = create_dummy_space::(caller.clone()); + let new_parent_space = create_dummy_space::(caller.clone()); + + assert!(space.content.is_none()); + assert!(space.permissions.is_none()); + + let space_update = SpaceUpdate { + content: dummy_space_content().into(), + hidden: true.into(), + permissions: Some(Some(::DefaultSpacePermissions::get())), + }; + }: _(RawOrigin::Signed(caller), space.id, space_update) + verify { + let space_from_storage = SpaceById::::get(space.id).expect("Updated space should exist"); + assert!(space_from_storage.content.is_some()); + assert!(space_from_storage.edited); + assert!(space_from_storage.permissions.is_some()); + } +} diff --git a/pallets/spaces/src/lib.rs b/pallets/spaces/src/lib.rs new file mode 100644 index 0000000..b86c63e --- /dev/null +++ b/pallets/spaces/src/lib.rs @@ -0,0 +1,434 @@ +//! # Spaces Module +//! +//! Spaces are the primary components of Subsocial. This module allows you to create a Space +//! and customize it by updating its' owner(s), content, and permissions. +//! +//! To understand how Spaces fit into the Subsocial ecosystem, you can think of how +//! folders and files work in a file system. Spaces are similar to folders, that can contain Posts, +//! in this sense. The permissions of the Space and Posts can be customized so that a Space +//! could be as simple as a personal blog (think of a page on Facebook) or as complex as community +//! (think of a subreddit) governed DAO. +//! +//! Spaces can be compared to existing entities on web 2.0 platforms such as: +//! +//! - Blogs on Blogger, +//! - Publications on Medium, +//! - Groups or pages on Facebook, +//! - Accounts on Twitter and Instagram, +//! - Channels on YouTube, +//! - Servers on Discord, +//! - Forums on Discourse. + +#![cfg_attr(not(feature = "std"), no_std)] + +pub use pallet::*; +use pallet_permissions::{SpacePermission, SpacePermissions}; +use subsocial_support::{traits::SpaceFollowsProvider, Content, SpaceId}; + +#[cfg(feature = "runtime-benchmarks")] +mod benchmarking; +pub mod weights; + +// pub mod rpc; +pub mod types; + +#[frame_support::pallet] +pub mod pallet { + use frame_support::pallet_prelude::*; + use frame_system::pallet_prelude::*; + use sp_std::vec::Vec; + + use pallet_permissions::{ + Pallet as Permissions, PermissionChecker, SpacePermissionsContext, SpacePermissionsInfoOf, + }; + use subsocial_support::{ + ensure_content_is_valid, remove_from_bounded_vec, + traits::{IsAccountBlocked, IsContentBlocked, SpacePermissionsProvider, SpacesInterface}, + ModerationError, SpacePermissionsInfo, WhoAndWhen, WhoAndWhenOf, + }; + use types::*; + + pub use crate::weights::WeightInfo; + + use super::*; + + #[pallet::config] + pub trait Config: + frame_system::Config + pallet_permissions::Config + pallet_timestamp::Config + { + /// The overarching event type. + type RuntimeEvent: From> + IsType<::RuntimeEvent>; + + type Roles: PermissionChecker; + + type SpaceFollows: SpaceFollowsProvider; + + type IsAccountBlocked: IsAccountBlocked; + + type IsContentBlocked: IsContentBlocked; + + #[pallet::constant] + type MaxSpacesPerAccount: Get; + + /// Weight information for extrinsics in this pallet. + type WeightInfo: WeightInfo; + } + + #[pallet::pallet] + #[pallet::generate_store(pub (super) trait Store)] + #[pallet::without_storage_info] + pub struct Pallet(_); + + #[pallet::event] + #[pallet::generate_deposit(pub (super) fn deposit_event)] + pub enum Event { + SpaceCreated { account: T::AccountId, space_id: SpaceId }, + SpaceUpdated { account: T::AccountId, space_id: SpaceId }, + } + + #[pallet::error] + pub enum Error { + /// Space was not found by id. + SpaceNotFound, + /// Nothing to update in this space. + NoUpdatesForSpace, + /// Only space owners can manage this space. + NotASpaceOwner, + /// User has no permission to update this space. + NoPermissionToUpdateSpace, + /// User has no permission to create subspaces within this space. + NoPermissionToCreateSubspaces, + /// Space is at root level, no `parent_id` specified. + SpaceIsAtRoot, + /// New spaces' settings don't differ from the old ones. + NoUpdatesForSpacesSettings, + /// There are too many spaces created by this account already + TooManySpacesPerAccount, + } + + #[pallet::type_value] + pub fn DefaultForNextSpaceId() -> SpaceId { + RESERVED_SPACE_COUNT + 1 + } + + /// The next space id. + #[pallet::storage] + #[pallet::getter(fn next_space_id)] + pub type NextSpaceId = StorageValue<_, SpaceId, ValueQuery, DefaultForNextSpaceId>; + + /// Get the details of a space by its' id. + #[pallet::storage] + #[pallet::getter(fn space_by_id)] + pub type SpaceById = StorageMap<_, Twox64Concat, SpaceId, Space>; + + /// Find the ids of all spaces owned, by a given account. + #[pallet::storage] + #[pallet::getter(fn space_ids_by_owner)] + pub type SpaceIdsByOwner = + StorageMap<_, Twox64Concat, T::AccountId, SpacesByAccount, ValueQuery>; + + #[pallet::genesis_config] + pub struct GenesisConfig { + pub endowed_account: Option, + } + + #[cfg(feature = "std")] + impl Default for GenesisConfig { + fn default() -> Self { + Self { endowed_account: None } + } + } + + #[pallet::genesis_build] + impl GenesisBuild for GenesisConfig { + fn build(&self) { + Pallet::::init_pallet(self.endowed_account.as_ref()); + } + } + + #[pallet::call] + impl Pallet { + #[pallet::call_index(0)] + #[pallet::weight(< T as Config >::WeightInfo::create_space())] + pub fn create_space( + origin: OriginFor, + content: Content, + permissions_opt: Option, + ) -> DispatchResult { + let owner = ensure_signed(origin)?; + + Self::do_create_space(&owner, content, permissions_opt)?; + Ok(()) + } + + #[pallet::call_index(1)] + #[pallet::weight(< T as Config >::WeightInfo::update_space())] + pub fn update_space( + origin: OriginFor, + space_id: SpaceId, + update: SpaceUpdate, + ) -> DispatchResult { + let owner = ensure_signed(origin)?; + + let has_updates = + update.content.is_some() || update.hidden.is_some() || update.permissions.is_some(); + + ensure!(has_updates, Error::::NoUpdatesForSpace); + + let mut space = Self::require_space(space_id)?; + + ensure!( + T::IsAccountBlocked::is_allowed_account(owner.clone(), space.id), + ModerationError::AccountIsBlocked + ); + + Self::ensure_account_has_space_permission( + owner.clone(), + &space, + SpacePermission::UpdateSpace, + Error::::NoPermissionToUpdateSpace.into(), + )?; + + let mut is_update_applied = false; + + if let Some(content) = update.content { + if content != space.content { + ensure_content_is_valid(content.clone())?; + + ensure!( + T::IsContentBlocked::is_allowed_content(content.clone(), space.id), + ModerationError::ContentIsBlocked + ); + + space.content = content; + space.edited = true; + is_update_applied = true; + } + } + + if let Some(hidden) = update.hidden { + if hidden != space.hidden { + space.hidden = hidden; + is_update_applied = true; + } + } + + if let Some(overrides_opt) = update.permissions { + if space.permissions != overrides_opt { + if let Some(overrides) = overrides_opt.clone() { + space.permissions = Some(Permissions::::override_permissions(overrides)); + } else { + space.permissions = overrides_opt; + } + + is_update_applied = true; + } + } + + // Update this space only if at least one field should be updated: + if is_update_applied { + SpaceById::::insert(space_id, space); + Self::deposit_event(Event::SpaceUpdated { account: owner, space_id }); + } + Ok(()) + } + + #[pallet::call_index(2)] + #[pallet::weight(( + Weight::from_ref_time(1_000_000) + T::DbWeight::get().reads_writes(1, 3), + DispatchClass::Operational, + Pays::Yes, + ))] + pub fn force_create_space( + origin: OriginFor, + space_id: SpaceId, + created: WhoAndWhenOf, + owner: T::AccountId, + content: Content, + hidden: bool, + permissions_opt: Option, + ) -> DispatchResultWithPostInfo { + ensure_root(origin)?; + + let permissions = + permissions_opt.map(|perms| Permissions::::override_permissions(perms)); + + let WhoAndWhen { account, time, .. } = created; + let new_who_and_when = + WhoAndWhen { account, block: frame_system::Pallet::::block_number(), time }; + + let new_space = &mut Space { + id: space_id, + created: new_who_and_when, + edited: false, + owner: owner.clone(), + content, + hidden, + permissions, + }; + + let add_new_space_id_by_owner = |owner: &T::AccountId, space_id: SpaceId| { + SpaceIdsByOwner::::mutate(&owner, |ids| { + ids.try_push(space_id).expect("qed; too many spaces per account") + }); + }; + + // To prevent incorrect [SpaceIdsByOwner] insertion, + // we check if the space already exists. + match Self::require_space(space_id) { + Ok(space) if !space.is_owner(&owner) => { + SpaceIdsByOwner::::mutate(&space.owner, |ids| { + remove_from_bounded_vec(ids, space_id) + }); + add_new_space_id_by_owner(&owner, space_id); + }, + Err(_) => add_new_space_id_by_owner(&owner, space_id), + _ => (), + } + + SpaceById::::insert(space_id, new_space); + + Self::deposit_event(Event::SpaceCreated { account: owner, space_id }); + + Ok(Pays::No.into()) + } + + #[pallet::call_index(3)] + #[pallet::weight(( + Weight::from_ref_time(10_000) + T::DbWeight::get().writes(1), + DispatchClass::Operational, + Pays::Yes, + ))] + pub fn force_set_next_space_id( + origin: OriginFor, + space_id: SpaceId, + ) -> DispatchResultWithPostInfo { + ensure_root(origin)?; + NextSpaceId::::put(space_id); + Ok(Pays::No.into()) + } + } + + impl Pallet { + /// Create reserved spaces either on genesis build or when pallet is added to a runtime. + pub fn init_pallet(endowed_account_opt: Option<&T::AccountId>) { + if let Some(endowed_account) = endowed_account_opt { + let mut spaces = Vec::new(); + + for id in FIRST_SPACE_ID..=RESERVED_SPACE_COUNT { + spaces.push(( + id, + Space::::new(id, endowed_account.clone(), Content::None, None), + )); + } + spaces.iter().for_each(|(space_id, space)| { + SpaceById::::insert(space_id, space); + }); + } + } + + fn do_create_space( + owner: &T::AccountId, + content: Content, + permissions_opt: Option, + ) -> Result { + ensure_content_is_valid(content.clone())?; + Self::ensure_space_limit_not_reached(owner)?; + + let permissions = + permissions_opt.map(|perms| Permissions::::override_permissions(perms)); + + let space_id = Self::next_space_id(); + let new_space = &mut Space::new(space_id, owner.clone(), content, permissions); + + SpaceById::::insert(space_id, new_space); + SpaceIdsByOwner::::mutate(owner, |ids| { + ids.try_push(space_id).expect("qed; too many spaces per account") + }); + NextSpaceId::::mutate(|n| *n += 1); + + Self::deposit_event(Event::SpaceCreated { account: owner.clone(), space_id }); + Ok(space_id) + } + + /// Check that there is a `Space` with such `space_id` in the storage + /// or return`SpaceNotFound` error. + pub fn ensure_space_exists(space_id: SpaceId) -> DispatchResult { + ensure!(>::contains_key(space_id), Error::::SpaceNotFound); + Ok(()) + } + + /// Get `Space` by id from the storage or return `SpaceNotFound` error. + pub fn require_space(space_id: SpaceId) -> Result, DispatchError> { + Ok(Self::space_by_id(space_id).ok_or(Error::::SpaceNotFound)?) + } + + pub fn ensure_account_has_space_permission( + account: T::AccountId, + space: &Space, + permission: SpacePermission, + error: DispatchError, + ) -> DispatchResult { + let is_owner = space.is_owner(&account); + let is_follower = space.is_follower(&account); + + let ctx = SpacePermissionsContext { + space_id: space.id, + is_space_owner: is_owner, + is_space_follower: is_follower, + space_perms: space.permissions.clone(), + }; + + T::Roles::ensure_account_has_space_permission(account, ctx, permission, error) + } + + pub fn mutate_space_by_id)>( + space_id: SpaceId, + f: F, + ) -> Result, DispatchError> { + >::try_mutate(space_id, |space_opt| { + if let Some(ref mut space) = space_opt.clone() { + f(space); + *space_opt = Some(space.clone()); + + return Ok(space.clone()); + } + + Err(Error::::SpaceNotFound.into()) + }) + } + + pub fn ensure_space_limit_not_reached(owner: &T::AccountId) -> DispatchResult { + ensure!( + Self::space_ids_by_owner(&owner).len() < T::MaxSpacesPerAccount::get() as usize, + Error::::TooManySpacesPerAccount, + ); + Ok(()) + } + } + + impl SpacePermissionsProvider> for Pallet { + fn space_permissions_info(id: SpaceId) -> Result, DispatchError> { + let space = Pallet::::require_space(id)?; + + Ok(SpacePermissionsInfo { owner: space.owner, permissions: space.permissions }) + } + + fn ensure_space_owner(id: SpaceId, account: &T::AccountId) -> DispatchResult { + let space = Pallet::::require_space(id)?; + ensure!(space.is_owner(account), Error::::NotASpaceOwner); + Ok(()) + } + } + + impl SpacesInterface for Pallet { + fn get_space_owner(space_id: SpaceId) -> Result { + let space = Pallet::::require_space(space_id)?; + Ok(space.owner) + } + + fn create_space(owner: &T::AccountId, content: Content) -> Result { + Self::do_create_space(owner, content, None) + } + } +} diff --git a/pallets/spaces/src/rpc.rs b/pallets/spaces/src/rpc.rs new file mode 100644 index 0000000..b63ab29 --- /dev/null +++ b/pallets/spaces/src/rpc.rs @@ -0,0 +1,142 @@ +use codec::{Decode, Encode}; +#[cfg(feature = "std")] +use serde::{Deserialize, Serialize}; +use sp_std::prelude::*; + +use pallet_utils::{bool_to_option, SpaceId, rpc::{FlatContent, FlatWhoAndWhen, ShouldSkip}}; + +use crate::{Config, Pallet, Space, FIRST_SPACE_ID}; + +#[derive(Eq, PartialEq, Encode, Decode, Default)] +#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))] +#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))] +pub struct FlatSpace { + pub id: SpaceId, + + #[cfg_attr(feature = "std", serde(flatten))] + pub who_and_when: FlatWhoAndWhen, + + pub owner_id: AccountId, + + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] + pub parent_id: Option, + + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip", serialize_with = "bytes_to_string"))] + pub handle: Option>, + + #[cfg_attr(feature = "std", serde(flatten))] + pub content: FlatContent, + + #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] + pub is_hidden: Option, + + pub posts_count: u32, + pub hidden_posts_count: u32, + pub visible_posts_count: u32, + pub followers_count: u32, +} + +#[cfg(feature = "std")] +fn bytes_to_string(field: &Option>, serializer: S) -> Result where S: serde::Serializer { + let field_unwrapped = field.clone().unwrap_or_default(); + // If Bytes slice is invalid, then empty string will be returned + serializer.serialize_str( + std::str::from_utf8(&field_unwrapped).unwrap_or_default() + ) +} + +impl From> for FlatSpace { + fn from(from: Space) -> Self { + let Space { + id, created, updated, owner, + parent_id, handle, content, hidden, posts_count, + hidden_posts_count, followers_count, .. + } = from; + + Self { + id, + who_and_when: (created, updated).into(), + owner_id: owner, + parent_id, + handle, + content: content.into(), + is_hidden: bool_to_option(hidden), + posts_count, + hidden_posts_count, + visible_posts_count: posts_count.saturating_sub(hidden_posts_count), + followers_count, + } + } +} + +impl Module { + pub fn get_spaces_by_ids(space_ids: Vec) -> Vec> { + space_ids.iter() + .filter_map(|id| Self::require_space(*id).ok()) + .map(|space| space.into()) + .collect() + } + + fn get_spaces_slice) -> bool>( + start_id: u64, + limit: u64, + mut filter: F, + ) -> Vec> { + let mut space_id = start_id; + let mut spaces = Vec::new(); + + while spaces.len() < limit as usize && space_id >= FIRST_SPACE_ID { + if let Ok(space) = Self::require_space(space_id) { + if filter(&space) { + spaces.push(space.into()); + } + } + space_id = space_id.saturating_sub(1); + } + + spaces + } + + pub fn get_spaces(start_id: u64, limit: u64) -> Vec> { + Self::get_spaces_slice(start_id, limit, |_| true) + } + + pub fn get_public_spaces(start_id: u64, limit: u64) -> Vec> { + Self::get_spaces_slice(start_id, limit, |space| space.is_public()) + } + + pub fn get_unlisted_spaces(start_id: u64, limit: u64) -> Vec> { + Self::get_spaces_slice(start_id, limit, |space| space.is_unlisted()) + } + + pub fn get_space_id_by_handle(handle: Vec) -> Option { + Self::space_id_by_handle(handle) + } + + pub fn get_space_by_handle(handle: Vec) -> Option> { + Self::space_id_by_handle(handle) + .and_then(|space_id| Self::require_space(space_id).ok()) + .map(|space| space.into()) + } + + fn get_space_ids_by_owner) -> bool>(owner: T::AccountId, mut compare_fn: F) -> Vec { + Self::space_ids_by_owner(owner) + .iter() + .filter_map(|space_id| Self::require_space(*space_id).ok()) + .filter(|space| compare_fn(space)) + .map(|space| space.id) + .collect() + } + + pub fn get_public_space_ids_by_owner(owner: T::AccountId) -> Vec { + Self::get_space_ids_by_owner(owner, |space| !space.hidden) + } + + pub fn get_unlisted_space_ids_by_owner(owner: T::AccountId) -> Vec { + Self::get_space_ids_by_owner(owner, |space| space.hidden) + } + + pub fn get_next_space_id() -> SpaceId { + Self::next_space_id() + } +} \ No newline at end of file diff --git a/pallets/spaces/src/types.rs b/pallets/spaces/src/types.rs new file mode 100644 index 0000000..a801b63 --- /dev/null +++ b/pallets/spaces/src/types.rs @@ -0,0 +1,83 @@ +use frame_support::pallet_prelude::*; + +use subsocial_support::{new_who_and_when, WhoAndWhenOf}; + +use super::*; + +pub const FIRST_SPACE_ID: u64 = 1; +pub const RESERVED_SPACE_COUNT: u64 = 1000; + +pub(crate) type SpacesByAccount = BoundedVec::MaxSpacesPerAccount>; + +/// Information about a space's owner, its' content, visibility and custom permissions. +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +#[scale_info(skip_type_params(T))] +pub struct Space { + /// Unique sequential identifier of a space. Examples of space ids: `1`, `2`, `3`, and so on. + pub id: SpaceId, + + pub created: WhoAndWhenOf, + /// True, if the content of this space was edited. + pub edited: bool, + + /// The current owner of a given space. + pub owner: T::AccountId, + + // The next fields can be updated by the owner: + pub content: Content, + + /// Hidden field is used to recommend to end clients (web and mobile apps) that a particular + /// space and its' posts should not be shown. + pub hidden: bool, + + /// This allows you to override Subsocial's default permissions by enabling or disabling role + /// permissions. + pub permissions: Option, +} + +#[derive(Encode, Decode, Clone, Eq, PartialEq, Default, RuntimeDebug, TypeInfo)] +pub struct SpaceUpdate { + pub content: Option, + pub hidden: Option, + pub permissions: Option>, +} + +impl Space { + pub fn new( + id: SpaceId, + created_by: T::AccountId, + content: Content, + permissions: Option, + ) -> Self { + Space { + id, + created: new_who_and_when::(created_by.clone()), + edited: false, + owner: created_by, + content, + hidden: false, + permissions, + } + } + + pub fn is_owner(&self, account: &T::AccountId) -> bool { + self.owner == *account + } + + pub fn is_follower(&self, account: &T::AccountId) -> bool { + T::SpaceFollows::is_space_follower(account.clone(), self.id) + } + + pub fn ensure_space_owner(&self, account: T::AccountId) -> DispatchResult { + ensure!(self.is_owner(&account), Error::::NotASpaceOwner); + Ok(()) + } + + pub fn is_public(&self) -> bool { + !self.hidden && self.content.is_some() + } + + pub fn is_unlisted(&self) -> bool { + !self.is_public() + } +} diff --git a/pallets/spaces/src/weights.rs b/pallets/spaces/src/weights.rs new file mode 100644 index 0000000..a9f796b --- /dev/null +++ b/pallets/spaces/src/weights.rs @@ -0,0 +1,91 @@ + +//! Autogenerated weights for pallet_spaces +//! +//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev +//! DATE: 2023-02-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` +//! HOSTNAME: `benchmarks-ci`, CPU: `Intel(R) Xeon(R) Platinum 8280 CPU @ 2.70GHz` +//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 + +// Executed Command: + // ./scripts/../target/release/subsocial-collator + // benchmark + // pallet + // --chain + // dev + // --execution + // wasm + // --wasm-execution + // Compiled + // --pallet + // pallet_spaces + // --extrinsic + // * + // --steps + // 50 + // --repeat + // 20 + // --heap-pages + // 4096 + // --output + // pallets/spaces/src/weights.rs + // --template + // ./.maintain/weight-template.hbs + +#![cfg_attr(rustfmt, rustfmt_skip)] +#![allow(unused_parens)] +#![allow(unused_imports)] +#![allow(non_snake_case)] + +use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; +use sp_std::marker::PhantomData; + +/// Weight functions needed for pallet_spaces. +pub trait WeightInfo { + fn create_space() -> Weight; + fn update_space() -> Weight; +} + +/// Weights for pallet_spaces using the Substrate node and recommended hardware. +pub struct SubstrateWeight(PhantomData); + impl WeightInfo for SubstrateWeight { + // Storage: Spaces SpaceIdsByOwner (r:1 w:1) + // Storage: Spaces NextSpaceId (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Spaces SpaceById (r:0 w:1) + fn create_space() -> Weight { + // Minimum execution time: 45_683 nanoseconds. + Weight::from_ref_time(46_598_000) + .saturating_add(T::DbWeight::get().reads(3)) + .saturating_add(T::DbWeight::get().writes(3)) + } + // Storage: Spaces SpaceById (r:1 w:1) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) + fn update_space() -> Weight { + // Minimum execution time: 52_466 nanoseconds. + Weight::from_ref_time(53_333_000) + .saturating_add(T::DbWeight::get().reads(2)) + .saturating_add(T::DbWeight::get().writes(1)) + } + } + + // For backwards compatibility and tests + impl WeightInfo for () { + // Storage: Spaces SpaceIdsByOwner (r:1 w:1) + // Storage: Spaces NextSpaceId (r:1 w:1) + // Storage: Timestamp Now (r:1 w:0) + // Storage: Spaces SpaceById (r:0 w:1) + fn create_space() -> Weight { + // Minimum execution time: 45_683 nanoseconds. + Weight::from_ref_time(46_598_000) + .saturating_add(RocksDbWeight::get().reads(3)) + .saturating_add(RocksDbWeight::get().writes(3)) + } + // Storage: Spaces SpaceById (r:1 w:1) + // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) + fn update_space() -> Weight { + // Minimum execution time: 52_466 nanoseconds. + Weight::from_ref_time(53_333_000) + .saturating_add(RocksDbWeight::get().reads(2)) + .saturating_add(RocksDbWeight::get().writes(1)) + } + } diff --git a/pallets/spaces/tests/Cargo.toml b/pallets/spaces/tests/Cargo.toml new file mode 100644 index 0000000..fb8c394 --- /dev/null +++ b/pallets/spaces/tests/Cargo.toml @@ -0,0 +1,58 @@ +[package] +name = 'pallet-spaces-tests' +version = '0.1.7' +authors = ['DappForce '] +edition = '2021' +license = 'GPL-3.0-only' +homepage = 'https://subsocial.network' +repository = 'https://github.com/dappforce/subsocial-parachain' +description = 'Spaces pallet tests' +keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] +categories = ['cryptography::cryptocurrencies'] + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } + +# Local dependencies +subsocial-support = { default-features = false, path = '../../support' } +pallet-permissions = { default-features = false, path = '../../permissions' } + +# Substrate dependencies +pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +pallet-spaces = { default-features = false, path = '..' } + +[dev-dependencies] +sp-core = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +sp-io = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } +pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } +pallet-roles = { default-features = false, path = '../../roles' } +pallet-space-follows = { default-features = false, path = '../../space-follows' } +pallet-profiles = { default-features = false, path = '../../profiles' } +pallet-posts = { default-features = false, path = '../../posts' } + +[features] +default = ['std'] +std = [ + 'codec/std', + 'scale-info/std', + 'pallet-timestamp/std', + 'frame-support/std', + 'frame-system/std', + 'sp-runtime/std', + 'sp-std/std', + 'pallet-permissions/std', + 'pallet-balances/std', + 'pallet-roles/std', + 'pallet-space-follows/std', + 'pallet-profiles/std', + 'pallet-posts/std', +] +try-runtime = ["frame-support/try-runtime"] diff --git a/pallets/spaces/tests/src/lib.rs b/pallets/spaces/tests/src/lib.rs new file mode 100644 index 0000000..71dc193 --- /dev/null +++ b/pallets/spaces/tests/src/lib.rs @@ -0,0 +1,6 @@ +#[cfg(test)] +mod mock; +#[cfg(test)] +mod tests; +#[cfg(test)] +mod tests_utils; diff --git a/pallets/spaces/tests/src/mock.rs b/pallets/spaces/tests/src/mock.rs new file mode 100644 index 0000000..18acd38 --- /dev/null +++ b/pallets/spaces/tests/src/mock.rs @@ -0,0 +1,144 @@ +use frame_support::{pallet_prelude::ConstU32, parameter_types, traits::Everything}; +use sp_core::H256; +use sp_runtime::{ + testing::Header, + traits::{BlakeTwo256, IdentityLookup}, +}; +use sp_std::convert::{TryFrom, TryInto}; + +use crate::tests_utils::*; + +type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; +type Block = frame_system::mocking::MockBlock; + +frame_support::construct_runtime!( + pub enum Test where + Block = Block, + NodeBlock = Block, + UncheckedExtrinsic = UncheckedExtrinsic, + { + System: frame_system, + Timestamp: pallet_timestamp, + Balances: pallet_balances, + Permissions: pallet_permissions, + Roles: pallet_roles, + Profiles: pallet_profiles, + SpaceFollows: pallet_space_follows, + Posts: pallet_posts, + Spaces: pallet_spaces, + } +); + +pub(super) type AccountId = u64; +pub(super) type Balance = u64; +pub(super) type BlockNumber = u64; + +parameter_types! { + pub const BlockHashCount: u64 = 250; + pub const SS58Prefix: u8 = 42; +} + +impl frame_system::Config for Test { + type BaseCallFilter = Everything; + type BlockWeights = (); + type BlockLength = (); + type RuntimeOrigin = RuntimeOrigin; + type RuntimeCall = RuntimeCall; + type Index = u64; + type BlockNumber = BlockNumber; + type Hash = H256; + type Hashing = BlakeTwo256; + type AccountId = AccountId; + type Lookup = IdentityLookup; + type Header = Header; + type RuntimeEvent = RuntimeEvent; + type BlockHashCount = BlockHashCount; + type DbWeight = (); + type Version = (); + type PalletInfo = PalletInfo; + type AccountData = pallet_balances::AccountData; + type OnNewAccount = (); + type OnKilledAccount = (); + type SystemWeightInfo = (); + type SS58Prefix = SS58Prefix; + type OnSetCode = (); + type MaxConsumers = frame_support::traits::ConstU32<16>; +} + +parameter_types! { + pub const MinimumPeriod: u64 = 5; +} + +impl pallet_timestamp::Config for Test { + type Moment = u64; + type OnTimestampSet = (); + type MinimumPeriod = MinimumPeriod; + type WeightInfo = (); +} + +parameter_types! { + pub const ExistentialDeposit: u64 = 1; +} + +impl pallet_balances::Config for Test { + type Balance = Balance; + type DustRemoval = (); + type RuntimeEvent = RuntimeEvent; + type ExistentialDeposit = ExistentialDeposit; + type AccountStore = System; + type WeightInfo = (); + type MaxLocks = (); + type MaxReserves = (); + type ReserveIdentifier = (); +} + +parameter_types! { + pub const MaxCommentDepth: u32 = 10; +} + +impl pallet_posts::Config for Test { + type RuntimeEvent = RuntimeEvent; + type MaxCommentDepth = MaxCommentDepth; + type IsPostBlocked = MockModeration; + type WeightInfo = (); +} + +impl pallet_permissions::Config for Test { + type DefaultSpacePermissions = pallet_permissions::default_permissions::DefaultSpacePermissions; +} + +parameter_types! { + pub const MaxUsersToProcessPerDeleteRole: u16 = 40; +} + +impl pallet_roles::Config for Test { + type RuntimeEvent = RuntimeEvent; + type MaxUsersToProcessPerDeleteRole = MaxUsersToProcessPerDeleteRole; + type SpacePermissionsProvider = Spaces; + type SpaceFollows = SpaceFollows; + type IsAccountBlocked = MockModeration; + type IsContentBlocked = MockModeration; + type WeightInfo = (); +} + +impl pallet_profiles::Config for Test { + type RuntimeEvent = RuntimeEvent; + type SpacePermissionsProvider = Spaces; + type SpacesInterface = Spaces; + type WeightInfo = (); +} + +impl pallet_spaces::Config for Test { + type RuntimeEvent = RuntimeEvent; + type Roles = Roles; + type SpaceFollows = SpaceFollows; + type IsAccountBlocked = MockModeration; + type IsContentBlocked = MockModeration; + type MaxSpacesPerAccount = ConstU32<100>; + type WeightInfo = (); +} + +impl pallet_space_follows::Config for Test { + type RuntimeEvent = RuntimeEvent; + type WeightInfo = (); +} diff --git a/pallets/spaces/tests/src/tests.rs b/pallets/spaces/tests/src/tests.rs new file mode 100644 index 0000000..ca4c76f --- /dev/null +++ b/pallets/spaces/tests/src/tests.rs @@ -0,0 +1,345 @@ +use frame_support::{assert_noop, assert_ok}; + +use pallet_permissions::SpacePermission as SP; +use pallet_spaces::Error as SpacesError; +use subsocial_support::{mock_functions::*, ContentError, ModerationError}; + +use crate::{mock::*, tests_utils::*}; + +#[test] +fn update_space_should_fail_when_account_is_blocked() { + ExtBuilder::build_with_space().execute_with(|| { + block_account_in_space_1(); + assert_noop!( + _update_space(None, None, Some(update_for_space_content(updated_space_content()))), + ModerationError::AccountIsBlocked, + ); + }); +} + +#[test] +fn update_space_should_fail_when_content_is_blocked() { + ExtBuilder::build_with_space().execute_with(|| { + block_content_in_space_1(); + assert_noop!( + _update_space(None, None, Some(space_update(Some(valid_content_ipfs()), None))), + ModerationError::ContentIsBlocked, + ); + }); +} + +#[test] +fn create_space_should_work() { + ExtBuilder::build().execute_with(|| { + assert_ok!(_create_default_space()); // SpaceId 1 + + // Check storages + assert_eq!(Spaces::space_ids_by_owner(ACCOUNT1), vec![SPACE1]); + assert_eq!(Spaces::next_space_id(), SPACE2); + + // Check whether data stored correctly + let space = Spaces::space_by_id(SPACE1).unwrap(); + + assert_eq!(space.created.account, ACCOUNT1); + assert!(!space.edited); + assert!(!space.hidden); + + assert_eq!(space.owner, ACCOUNT1); + assert_eq!(space.content, space_content_ipfs()); + }); +} + +#[test] +fn create_space_should_work_with_permissions_override() { + let perms = permissions_where_everyone_can_create_post(); + ExtBuilder::build_with_space_and_custom_permissions(perms.clone()).execute_with(|| { + let space = Spaces::space_by_id(SPACE1).unwrap(); + assert_eq!(space.permissions, Some(perms)); + }); +} + +#[test] +fn create_post_should_work_overridden_space_permission_for_everyone() { + ExtBuilder::build_with_space_and_custom_permissions( + permissions_where_everyone_can_create_post(), + ) + .execute_with(|| { + assert_ok!(_create_post(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None, None)); + }); +} + +#[test] +fn create_post_should_work_overridden_space_permission_for_followers() { + ExtBuilder::build_with_space_and_custom_permissions( + permissions_where_follower_can_create_post(), + ) + .execute_with(|| { + assert_ok!(_default_follow_space()); + + assert_ok!(_create_post(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None, None)); + }); +} + +#[test] +fn create_space_should_fail_when_ipfs_cid_is_invalid() { + ExtBuilder::build().execute_with(|| { + // Try to catch an error creating a space with invalid content + assert_noop!( + _create_space(None, Some(invalid_content_ipfs()), None), + ContentError::InvalidIpfsCid, + ); + }); +} + +#[test] +fn update_space_should_work() { + ExtBuilder::build_with_space().execute_with(|| { + let expected_content_ipfs = updated_space_content(); + // Space update with ID 1 should be fine + + assert_ok!(_update_space( + None, // From ACCOUNT1 (has permission as he's an owner) + None, + Some(space_update(Some(expected_content_ipfs.clone()), Some(true),)) + )); + + // Check whether space updates correctly + let space = Spaces::space_by_id(SPACE1).unwrap(); + assert_eq!(space.content, expected_content_ipfs); + assert!(space.hidden); + }); +} + +#[test] +fn update_space_should_work_when_one_of_roles_is_permitted() { + ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::UpdateSpace]).execute_with( + || { + let space_update = space_update(Some(updated_space_content()), Some(true)); + + assert_ok!(_update_space( + Some(RuntimeOrigin::signed(ACCOUNT2)), + Some(SPACE1), + Some(space_update) + )); + }, + ); +} + +#[test] +fn update_space_should_fail_when_no_updates_for_space_provided() { + ExtBuilder::build_with_space().execute_with(|| { + // Try to catch an error updating a space with no changes + assert_noop!(_update_space(None, None, None), SpacesError::::NoUpdatesForSpace); + }); +} + +#[test] +fn update_space_should_fail_when_space_not_found() { + ExtBuilder::build_with_space().execute_with(|| { + // Try to catch an error updating a space with wrong space ID + assert_noop!( + _update_space( + None, + Some(SPACE2), + Some(update_for_space_content(updated_space_content())) + ), + SpacesError::::SpaceNotFound + ); + }); +} + +#[test] +fn update_space_should_fail_when_account_has_no_permission_to_update_space() { + ExtBuilder::build_with_space().execute_with(|| { + // Try to catch an error updating a space with an account that it not permitted + assert_noop!( + _update_space( + Some(RuntimeOrigin::signed(ACCOUNT2)), + None, + Some(update_for_space_content(updated_space_content())) + ), + SpacesError::::NoPermissionToUpdateSpace + ); + }); +} + +#[test] +fn update_space_should_fail_when_ipfs_cid_is_invalid() { + ExtBuilder::build_with_space().execute_with(|| { + // Try to catch an error updating a space with invalid content + assert_noop!( + _update_space(None, None, Some(space_update(Some(invalid_content_ipfs()), None,))), + ContentError::InvalidIpfsCid, + ); + }); +} + +#[test] +fn update_space_should_fail_when_no_right_permission_in_account_roles() { + ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::UpdateSpace]).execute_with( + || { + let space_update = space_update(Some(updated_space_content()), Some(true)); + + assert_ok!(_delete_default_role()); + + assert_noop!( + _update_space(Some(RuntimeOrigin::signed(ACCOUNT2)), Some(SPACE1), Some(space_update)), + SpacesError::::NoPermissionToUpdateSpace + ); + }, + ); +} + +// TODO: refactor or remove. Deprecated tests +// Find public space ids tests +// -------------------------------------------------------------------------------------------- +/*#[test] +fn find_public_space_ids_should_work() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!(_create_space(None, None, Some(Some(space_handle1())), None, None)); + + let space_ids = Spaces::find_public_space_ids(0, 3); + assert_eq!(space_ids, vec![SPACE1, SPACE2]); + }); +} + +#[test] +fn find_public_space_ids_should_work_with_zero_offset() { + ExtBuilder::build_with_space().execute_with(|| { + let space_ids = Spaces::find_public_space_ids(0, 1); + assert_eq!(space_ids, vec![SPACE1]); + }); +} + +#[test] +fn find_public_space_ids_should_work_with_zero_limit() { + ExtBuilder::build_with_space().execute_with(|| { + let space_ids = Spaces::find_public_space_ids(1, 0); + assert_eq!(space_ids, vec![SPACE1]); + }); +} + +#[test] +fn find_public_space_ids_should_work_with_zero_offset_and_zero_limit() { + ExtBuilder::build_with_space().execute_with(|| { + let space_ids = Spaces::find_public_space_ids(0, 0); + assert_eq!(space_ids, vec![]); + }); +} + +// Find unlisted space ids tests +// -------------------------------------------------------------------------------------------- + +#[test] +fn find_unlisted_space_ids_should_work() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!(_create_space(None, None, Some(Some(space_handle1())), None, None)); + assert_ok!( + _update_space( + None, + Some(SPACE1), + Some( + space_update( + None, + None, + Some(Content::None), + Some(true), + None + ) + ) + ) + ); + + assert_ok!( + _update_space( + None, + Some(SPACE2), + Some( + space_update( + None, + None, + Some(Content::None), + Some(true), + None + ) + ) + ) + ); + + + let space_ids = Spaces::find_unlisted_space_ids(0, 2); + assert_eq!(space_ids, vec![SPACE1, SPACE2]); + }); +} + +#[test] +fn find_unlisted_space_ids_should_work_with_zero_offset() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!( + _update_space( + None, + Some(SPACE1), + Some( + space_update( + None, + None, + Some(Content::None), + Some(true), + None + ) + ) + ) + ); + + let space_ids = Spaces::find_unlisted_space_ids(0, 1); + assert_eq!(space_ids, vec![SPACE1]); + }); +} + +#[test] +fn find_unlisted_space_ids_should_work_with_zero_limit() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!( + _update_space( + None, + Some(SPACE1), + Some( + space_update( + None, + None, + Some(Content::None), + Some(true), + None + ) + ) + ) + ); + + let space_ids = Spaces::find_unlisted_space_ids(1, 0); + assert_eq!(space_ids, vec![]); + }); +} + +#[test] +fn find_unlisted_space_ids_should_work_with_zero_offset_and_zero_limit() { + ExtBuilder::build_with_space().execute_with(|| { + assert_ok!( + _update_space( + None, + Some(SPACE1), + Some( + space_update( + None, + None, + Some(Content::None), + Some(true), + None + ) + ) + ) + ); + + let space_ids = Spaces::find_unlisted_space_ids(0, 0); + assert_eq!(space_ids, vec![]); + }); +}*/ diff --git a/pallets/spaces/tests/src/tests_utils.rs b/pallets/spaces/tests/src/tests_utils.rs new file mode 100644 index 0000000..4b483b5 --- /dev/null +++ b/pallets/spaces/tests/src/tests_utils.rs @@ -0,0 +1,396 @@ +use std::{ + cell::RefCell, + collections::HashMap, + hash::{Hash, Hasher}, +}; + +use frame_support::{assert_ok, pallet_prelude::*}; +use sp_core::storage::Storage; +use sp_io::TestExternalities; + +use pallet_permissions::{ + default_permissions::DefaultSpacePermissions, SpacePermission as SP, SpacePermission, + SpacePermissions, +}; +use pallet_posts::PostExtension; +use pallet_spaces::types::SpaceUpdate; +use subsocial_support::{ + mock_functions::valid_content_ipfs, + traits::{IsAccountBlocked, IsContentBlocked, IsPostBlocked, IsSpaceBlocked}, + Content, PostId, SpaceId, User, +}; + +use crate::mock::*; + +////// Ext Builder + +pub struct ExtBuilder; + +impl ExtBuilder { + fn configure_storages(storage: &mut Storage) { + let mut accounts = Vec::new(); + for account in ACCOUNT1..=ACCOUNT3 { + accounts.push(account); + } + + let _ = pallet_balances::GenesisConfig:: { + balances: accounts.iter().cloned().map(|k| (k, 100)).collect(), + } + .assimilate_storage(storage); + } + + /// Default ext configuration with BlockNumber 1 + pub fn build() -> TestExternalities { + let mut storage = frame_system::GenesisConfig::default().build_storage::().unwrap(); + + Self::configure_storages(&mut storage); + + let mut ext = TestExternalities::from(storage); + ext.execute_with(|| System::set_block_number(1)); + + ext + } + + fn add_default_space() { + assert_ok!(_create_default_space()); + } + + fn add_space_with_custom_permissions(permissions: SpacePermissions) { + assert_ok!(_create_space(None, None, Some(Some(permissions)))); + } + + /// Custom ext configuration with SpaceId 1 and BlockNumber 1 + pub fn build_with_space() -> TestExternalities { + let mut ext = Self::build(); + ext.execute_with(Self::add_default_space); + ext + } + + /// Custom ext configuration with specified permissions granted (includes SpaceId 1) + pub fn build_with_a_few_roles_granted_to_account2(perms: Vec) -> TestExternalities { + let mut ext = Self::build_with_space(); + + ext.execute_with(|| { + let user = User::Account(ACCOUNT2); + assert_ok!(_create_default_role_with_permissions(perms)); // RoleId 1 + assert_ok!(_create_default_role()); // RoleId 2 + + assert_ok!(_grant_role(None, Some(ROLE1), Some(vec![user.clone()]))); + assert_ok!(_grant_role(None, Some(ROLE2), Some(vec![user]))); + }); + + ext + } + + /// Custom ext configuration with a space and override the space permissions + pub fn build_with_space_and_custom_permissions( + permissions: SpacePermissions, + ) -> TestExternalities { + let mut ext = Self::build(); + ext.execute_with(|| Self::add_space_with_custom_permissions(permissions)); + ext + } +} + +////// Consts + +pub(crate) const ACCOUNT1: AccountId = 1; +pub(crate) const ACCOUNT2: AccountId = 2; +pub(crate) const ACCOUNT3: AccountId = 3; + +pub(crate) const SPACE1: SpaceId = 1001; +pub(crate) const SPACE2: SpaceId = 1002; + +type RoleId = u64; + +pub(crate) const ROLE1: RoleId = 1; +pub(crate) const ROLE2: RoleId = 2; + +////// Moderation Utils + +// Moderation pallet mocks + +/* ------------------------------------------------------------------------------------------------ */ +// Moderation tests + +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug)] +pub enum EntityId { + Content(Content), + Account(AccountId), + Space(SpaceId), + Post(PostId), +} + +impl Hash for EntityId { + fn hash(&self, state: &mut H) { + match self { + EntityId::Content(content) => match content { + Content::None => 0.hash(state), + Content::Other(content) => content.hash(state), + Content::IPFS(content) => content.hash(state), + }, + EntityId::Account(account) => account.hash(state), + EntityId::Space(space) => space.hash(state), + EntityId::Post(post) => post.hash(state), + } + } +} + +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, Hash)] +pub enum EntityStatus { + Allowed, + Blocked, +} + +thread_local! { + pub static MOCK_MODERATION_STATE: RefCell> = RefCell::new(Default::default()); +} +pub struct MockModeration; + +impl MockModeration { + fn set_entity_status(entity: EntityId, space: SpaceId, status: EntityStatus) { + MOCK_MODERATION_STATE.with(|mock_moderation_state| { + let mut mock_moderation_state = mock_moderation_state.borrow_mut(); + mock_moderation_state.insert((entity, space), status); + }); + } + + fn get_entity_status(id: EntityId, scope: SpaceId) -> Option { + MOCK_MODERATION_STATE.with(|mock_moderation_state| { + let mock_moderation_state = mock_moderation_state.borrow(); + let status = mock_moderation_state.get(&(id, scope)).cloned(); + status + }) + } + + fn is_allowed_entity(id: EntityId, scope: SpaceId) -> bool { + Self::get_entity_status(id, scope).unwrap_or(EntityStatus::Allowed) == EntityStatus::Allowed + } + + fn is_blocked_entity(id: EntityId, scope: SpaceId) -> bool { + Self::get_entity_status(id, scope) == Some(EntityStatus::Blocked) + } +} + +impl IsPostBlocked for MockModeration { + fn is_blocked_post(post_id: PostId, scope: SpaceId) -> bool { + Self::is_blocked_entity(EntityId::Post(post_id), scope) + } + + fn is_allowed_post(post_id: PostId, scope: SpaceId) -> bool { + Self::is_allowed_entity(EntityId::Post(post_id), scope) + } +} + +impl IsAccountBlocked for MockModeration { + fn is_blocked_account(account: AccountId, scope: SpaceId) -> bool { + Self::is_blocked_entity(EntityId::Account(account), scope) + } + + fn is_allowed_account(account: AccountId, scope: SpaceId) -> bool { + Self::is_allowed_entity(EntityId::Account(account), scope) + } +} + +impl IsSpaceBlocked for MockModeration { + fn is_blocked_space(space_id: SpaceId, scope: SpaceId) -> bool { + Self::is_blocked_entity(EntityId::Space(space_id), scope) + } + + fn is_allowed_space(space_id: SpaceId, scope: SpaceId) -> bool { + Self::is_allowed_entity(EntityId::Space(space_id), scope) + } +} + +impl IsContentBlocked for MockModeration { + fn is_blocked_content(content: Content, scope: SpaceId) -> bool { + Self::is_blocked_entity(EntityId::Content(content), scope) + } + + fn is_allowed_content(content: Content, scope: SpaceId) -> bool { + Self::is_allowed_entity(EntityId::Content(content), scope) + } +} + +pub(crate) fn block_account_in_space_1() { + MockModeration::set_entity_status(EntityId::Account(ACCOUNT1), SPACE1, EntityStatus::Blocked); +} + +pub(crate) fn block_content_in_space_1() { + MockModeration::set_entity_status( + EntityId::Content(valid_content_ipfs()), + SPACE1, + EntityStatus::Blocked, + ); +} + +///////////// Space Utils + +pub(crate) fn space_content_ipfs() -> Content { + Content::IPFS(b"bafyreib3mgbou4xln42qqcgj6qlt3cif35x4ribisxgq7unhpun525l54e".to_vec()) +} + +pub(crate) fn updated_space_content() -> Content { + Content::IPFS(b"QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW2CuDgwxkD4".to_vec()) +} + +pub(crate) fn update_for_space_content(new_content: Content) -> SpaceUpdate { + space_update(Some(new_content), None) +} + +pub(crate) fn space_update(content: Option, hidden: Option) -> SpaceUpdate { + SpaceUpdate { content, hidden, permissions: None } +} + +pub(crate) fn _create_default_space() -> DispatchResult { + _create_space(None, None, None) +} + +pub(crate) fn _create_space( + origin: Option, + content: Option, + permissions: Option>, +) -> DispatchResult { + Spaces::create_space( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + content.unwrap_or_else(space_content_ipfs), + permissions.unwrap_or_default(), + ) +} + +pub(crate) fn _create_space_with_content(content: Content) -> DispatchResult { + _create_space(None, Some(content), None) +} + +pub(crate) fn _update_space( + origin: Option, + space_id: Option, + update: Option, +) -> DispatchResult { + Spaces::update_space( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + space_id.unwrap_or(SPACE1), + update.unwrap_or_else(|| space_update(None, None)), + ) +} + +///////////// Post Utils + +pub(crate) fn post_content_ipfs() -> Content { + Content::IPFS(b"bafyreidzue2dtxpj6n4x5mktrt7las5wz5diqma47zr25uau743dhe76we".to_vec()) +} + +pub(crate) fn extension_regular_post() -> PostExtension { + PostExtension::RegularPost +} + +pub(crate) fn _create_default_post() -> DispatchResult { + _create_post(None, None, None, None) +} + +pub(crate) fn _create_post( + origin: Option, + space_id_opt: Option>, + extension: Option, + content: Option, +) -> DispatchResult { + Posts::create_post( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + space_id_opt.unwrap_or(Some(SPACE1)), + extension.unwrap_or_else(extension_regular_post), + content.unwrap_or_else(post_content_ipfs), + ) +} + +//// Space follows utils + +pub(crate) fn _default_follow_space() -> DispatchResult { + _follow_space(None, None) +} + +pub(crate) fn _follow_space(origin: Option, space_id: Option) -> DispatchResult { + SpaceFollows::follow_space( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT2)), + space_id.unwrap_or(SPACE1), + ) +} + +/////// Roles utils + +pub(crate) fn default_role_content_ipfs() -> Content { + Content::IPFS(b"QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD4".to_vec()) +} + +pub(crate) fn _create_default_role() -> DispatchResult { + _create_role(None, None, None, None, None) +} + +pub(crate) fn _create_role( + origin: Option, + space_id: Option, + time_to_live: Option>, + content: Option, + permissions: Option>, +) -> DispatchResult { + // TODO: remove + Roles::create_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + space_id.unwrap_or(SPACE1), + time_to_live.unwrap_or_default(), // Should return 'None' + content.unwrap_or_else(default_role_content_ipfs), + permissions.unwrap_or_else(permission_set_default), + ) +} + +pub(crate) fn _create_default_role_with_permissions(permissions: Vec) -> DispatchResult { + _create_role(None, None, None, None, Some(permissions)) +} + +pub(crate) fn _grant_role( + origin: Option, + role_id: Option, + users: Option>>, +) -> DispatchResult { + Roles::grant_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + role_id.unwrap_or(ROLE1), + users.unwrap_or_else(|| vec![User::Account(ACCOUNT2)]), + ) +} + +pub(crate) fn _delete_default_role() -> DispatchResult { + _delete_role(None, None) +} + +pub(crate) fn _delete_role(origin: Option, role_id: Option) -> DispatchResult { + let users_count = Roles::users_by_role_id(role_id.unwrap_or(ROLE1)).len(); + Roles::delete_role( + origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), + role_id.unwrap_or(ROLE1), + users_count as u32, + ) +} + +/////// Permissions utils + +pub(crate) fn permissions_where_everyone_can_create_post() -> SpacePermissions { + let mut default_permissions = DefaultSpacePermissions::get(); + default_permissions.everyone = default_permissions.everyone.map(|mut permissions| { + permissions.insert(SP::CreatePosts); + permissions + }); + + default_permissions +} + +pub(crate) fn permissions_where_follower_can_create_post() -> SpacePermissions { + let mut default_permissions = DefaultSpacePermissions::get(); + default_permissions.follower = Some(vec![SP::CreatePosts].into_iter().collect()); + + default_permissions +} + +/// Permissions Set that includes next permission: ManageRoles +pub(crate) fn permission_set_default() -> Vec { + vec![SP::ManageRoles] +} diff --git a/pallets/support/Cargo.toml b/pallets/support/Cargo.toml new file mode 100644 index 0000000..d28c46d --- /dev/null +++ b/pallets/support/Cargo.toml @@ -0,0 +1,35 @@ +[package] +name = "subsocial-support" +version = "0.1.7" +authors = ["DappForce "] +edition = "2021" +license = "GPL-3.0-only" +homepage = "https://subsocial.network" +repository = "https://github.com/dappforce/subsocial-parachain" +description = "Pallet with common utils for the parachain node" +keywords = ["blockchain", "cryptocurrency", "social-network", "news-feed", "marketplace"] +categories = ["cryptography::cryptocurrencies"] + +[features] +default = ["std"] +std = [ + "strum/std", + "codec/std", + "scale-info/std", + "frame-support/std", + "frame-system/std", + "pallet-timestamp/std", + "sp-std/std", +] + +[dependencies] +strum = { version = "0.24", default-features = false, features = ["derive"] } + +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } +scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } + +# Substrate dependencies +frame-support = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } +frame-system = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } +pallet-timestamp = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } +sp-std = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } diff --git a/pallets/support/src/lib.rs b/pallets/support/src/lib.rs new file mode 100644 index 0000000..8e9b7df --- /dev/null +++ b/pallets/support/src/lib.rs @@ -0,0 +1,256 @@ +// TODO Try to reuse these utility functions via crate in the future, +// when solochain and parachain will use the same substrate version. + +#![cfg_attr(not(feature = "std"), no_std)] + +use codec::{Decode, Encode}; +use scale_info::TypeInfo; + +use frame_support::pallet_prelude::*; +use sp_std::{collections::btree_set::BTreeSet, vec, vec::Vec}; + +pub mod traits; + +pub type SpaceId = u64; +pub type PostId = u64; + +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +pub struct WhoAndWhen { + pub account: AccountId, + pub block: BlockNumber, + pub time: Moment, +} + +pub type WhoAndWhenOf = WhoAndWhen< + ::AccountId, + ::BlockNumber, + ::Moment, +>; + +pub fn new_who_and_when( + account: T::AccountId, +) -> WhoAndWhen +where + T: frame_system::Config + pallet_timestamp::Config, +{ + WhoAndWhen { + account, + block: frame_system::Pallet::::block_number(), + time: pallet_timestamp::Pallet::::now(), + } +} + +#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +pub enum Content { + /// No content. + None, + /// A raw vector of bytes. + Other(Vec), + /// IPFS CID v0 of content. + IPFS(Vec), +} + +impl From for Vec { + fn from(content: Content) -> Vec { + match content { + Content::None => vec![], + Content::Other(vec_u8) => vec_u8, + Content::IPFS(vec_u8) => vec_u8, + } + } +} + +impl Default for Content { + fn default() -> Self { + Self::None + } +} + +impl Content { + pub fn is_none(&self) -> bool { + self == &Self::None + } + + pub fn is_some(&self) -> bool { + !self.is_none() + } + + pub fn is_ipfs(&self) -> bool { + matches!(self, Self::IPFS(_)) + } +} + +#[derive(Encode, Decode, Ord, PartialOrd, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] +pub enum User { + Account(AccountId), + Space(SpaceId), +} + +impl User { + pub fn maybe_account(self) -> Option { + if let User::Account(account_id) = self { + Some(account_id) + } else { + None + } + } + + pub fn maybe_space(self) -> Option { + if let User::Space(space_id) = self { + Some(space_id) + } else { + None + } + } +} + +pub fn convert_users_vec_to_btree_set( + users_vec: Vec>, +) -> Result>, DispatchError> { + let mut users_set: BTreeSet> = BTreeSet::new(); + + for user in users_vec.iter() { + users_set.insert(user.clone()); + } + + Ok(users_set) +} + +#[derive(Encode, Decode, RuntimeDebug, strum::IntoStaticStr)] +pub enum ModerationError { + /// Account is blocked in a given space. + AccountIsBlocked, + /// Content is blocked in a given space. + ContentIsBlocked, + /// Post is blocked in a given space. + PostIsBlocked, + /// Space handle is too short. + HandleIsTooShort, + /// Space handle is too long. + HandleIsTooLong, + /// Space handle contains invalid characters. + HandleContainsInvalidChars, +} + +impl From for DispatchError { + fn from(err: ModerationError) -> DispatchError { + Self::Other(err.into()) + } +} + +#[derive(Encode, Decode, RuntimeDebug, strum::IntoStaticStr)] +pub enum ContentError { + /// IPFS CID is invalid. + InvalidIpfsCid, + /// `Other` content type is not yet supported. + OtherContentTypeNotSupported, + /// Content type is `None`. + ContentIsEmpty, +} + +impl From for DispatchError { + fn from(err: ContentError) -> DispatchError { + Self::Other(err.into()) + } +} + +/// Minimal set of fields from Space struct that are required by roles pallet. +pub struct SpacePermissionsInfo { + pub owner: AccountId, + pub permissions: Option, +} + +pub fn ensure_content_is_valid(content: Content) -> DispatchResult { + match content { + Content::None => Ok(()), + Content::Other(_) => Err(ContentError::OtherContentTypeNotSupported.into()), + Content::IPFS(ipfs_cid) => { + let len = ipfs_cid.len(); + // IPFS CID v0 is 46 bytes. + // IPFS CID v1 is 59 bytes. + ensure!(len == 46 || len == 59, ContentError::InvalidIpfsCid); + Ok(()) + }, + } +} + +/// Ensure that a given content is not `None`. +pub fn ensure_content_is_some(content: &Content) -> DispatchResult { + ensure!(content.is_some(), ContentError::ContentIsEmpty); + Ok(()) +} + +pub fn remove_from_vec(vector: &mut Vec, element: F) { + if let Some(index) = vector.iter().position(|x| *x == element) { + vector.swap_remove(index); + } +} + +pub fn remove_from_bounded_vec(vector: &mut BoundedVec, element: F) { + if let Some(index) = vector.iter().position(|x| *x == element) { + vector.swap_remove(index); + } +} + +pub fn bool_to_option(value: bool) -> Option { + if value { + Some(value) + } else { + None + } +} + +pub mod mock_functions { + use super::Content; + + pub fn valid_content_ipfs() -> Content { + Content::IPFS(b"QmRAQB6YaCaidP37UdDnjFY5aQuiBrbqdyoW1CaDgwxkD4".to_vec()) + } + + pub fn another_valid_content_ipfs() -> Content { + // Only the last character is changed, only for testing purposes. + Content::IPFS(b"QmRAQB6YaCaidP37UdDnjFY5aQuiBrbqdyoW1CaDgwxkD5".to_vec()) + } + + pub fn invalid_content_ipfs() -> Content { + Content::IPFS(b"QmRAQB6DaazhR8".to_vec()) + } +} + +#[cfg(test)] +mod tests { + use super::remove_from_vec; + + #[test] + fn remove_from_vec_should_work_with_zero_elements() { + let element: u16 = 2; + let vector: &mut Vec = &mut vec![]; + + remove_from_vec(vector, element); + assert!(vector.is_empty()); + } + + #[test] + fn remove_from_vec_should_work_with_last_element() { + let element: u16 = 2; + let vector: &mut Vec = &mut vec![6, 2]; + + vector.remove(0); + assert_eq!(vector, &mut vec![2]); + + remove_from_vec(vector, element); + assert!(vector.is_empty()); + } + + #[test] + fn remove_from_vec_should_work_with_two_elements() { + let element: u16 = 2; + let vector: &mut Vec = &mut vec![6, 2, 7]; + + vector.remove(0); + assert_eq!(vector, &mut vec![2, 7]); + + remove_from_vec(vector, element); + assert_eq!(vector, &mut vec![7]); + } +} diff --git a/pallets/support/src/traits.rs b/pallets/support/src/traits.rs new file mode 100644 index 0000000..04a08a5 --- /dev/null +++ b/pallets/support/src/traits.rs @@ -0,0 +1,7 @@ +pub use common::{ + ProfileManager, SpaceFollowsProvider, SpacePermissionsProvider, SpacesInterface, +}; +pub use moderation::{IsAccountBlocked, IsContentBlocked, IsPostBlocked, IsSpaceBlocked}; + +mod common; +mod moderation; diff --git a/pallets/support/src/traits/common.rs b/pallets/support/src/traits/common.rs new file mode 100644 index 0000000..fccc185 --- /dev/null +++ b/pallets/support/src/traits/common.rs @@ -0,0 +1,27 @@ +#![cfg_attr(not(feature = "std"), no_std)] + +use frame_support::dispatch::{DispatchError, DispatchResult}; + +use crate::{Content, SpaceId}; + +pub trait SpacePermissionsProvider { + fn space_permissions_info(id: SpaceId) -> Result; + + fn ensure_space_owner(id: SpaceId, account: &AccountId) -> DispatchResult; +} + +pub trait SpaceFollowsProvider { + type AccountId; + + fn is_space_follower(account: Self::AccountId, space_id: SpaceId) -> bool; +} + +pub trait ProfileManager { + fn unlink_space_from_profile(account: &AccountId, space_id: SpaceId); +} + +pub trait SpacesInterface { + fn get_space_owner(space_id: SpaceId) -> Result; + + fn create_space(owner: &AccountId, content: Content) -> Result; +} diff --git a/pallets/support/src/traits/moderation.rs b/pallets/support/src/traits/moderation.rs new file mode 100644 index 0000000..c2ef620 --- /dev/null +++ b/pallets/support/src/traits/moderation.rs @@ -0,0 +1,51 @@ +use crate::{Content, SpaceId}; + +pub trait IsAccountBlocked { + fn is_blocked_account(account: AccountId, scope: SpaceId) -> bool; + fn is_allowed_account(account: AccountId, scope: SpaceId) -> bool; +} + +impl IsAccountBlocked for () { + fn is_blocked_account(_account: AccountId, _scope: u64) -> bool { + false + } + + fn is_allowed_account(_account: AccountId, _scope: u64) -> bool { + true + } +} + +pub trait IsSpaceBlocked { + fn is_blocked_space(space_id: SpaceId, scope: SpaceId) -> bool; + fn is_allowed_space(space_id: SpaceId, scope: SpaceId) -> bool; +} + +// TODO: reuse `type PostId` from pallet_utils in future updates +pub trait IsPostBlocked { + fn is_blocked_post(post_id: PostId, scope: SpaceId) -> bool; + fn is_allowed_post(post_id: PostId, scope: SpaceId) -> bool; +} + +impl IsPostBlocked for () { + fn is_blocked_post(_post_id: PostId, _scope: SpaceId) -> bool { + false + } + + fn is_allowed_post(_post_id: PostId, _scope: u64) -> bool { + true + } +} + +pub trait IsContentBlocked { + fn is_blocked_content(content: Content, scope: SpaceId) -> bool; + fn is_allowed_content(content: Content, scope: SpaceId) -> bool; +} + +impl IsContentBlocked for () { + fn is_blocked_content(_content: Content, _scope: u64) -> bool { + false + } + fn is_allowed_content(_content: Content, _scope: SpaceId) -> bool { + true + } +} diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index ee7161e..2482de0 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -23,7 +23,7 @@ pallet-grandpa = { version = "4.0.0-dev", default-features = false, git = "https pallet-randomness-collective-flip = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } pallet-sudo = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } frame-system = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -frame-try-runtime = { version = "0.10.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", optional = true , branch = "polkadot-v0.9.37" } +frame-try-runtime = { version = "0.10.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", optional = true, branch = "polkadot-v0.9.37" } pallet-timestamp = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } frame-executive = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } @@ -44,72 +44,88 @@ frame-system-rpc-runtime-api = { version = "4.0.0-dev", default-features = false pallet-transaction-payment-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } # Used for runtime benchmarking -frame-benchmarking = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", optional = true , branch = "polkadot-v0.9.37" } -frame-system-benchmarking = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", optional = true , branch = "polkadot-v0.9.37" } +frame-benchmarking = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", optional = true, branch = "polkadot-v0.9.37" } +frame-system-benchmarking = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", optional = true, branch = "polkadot-v0.9.37" } # Local Dependencies pallet-template = { version = "4.0.0-dev", default-features = false, path = "../pallets/template" } +pallet-permissions = { default-features = false, path = '../pallets/permissions' } +pallet-spaces = { default-features = false, path = '../pallets/spaces' } +pallet-posts = { default-features = false, path = '../pallets/posts' } +pallet-roles = { default-features = false, path = '../pallets/roles' } +pallet-space-follows = { default-features = false, path = '../pallets/space-follows' } + [build-dependencies] -substrate-wasm-builder = { version = "5.0.0-dev", git = "https://github.com/paritytech/substrate.git", optional = true , branch = "polkadot-v0.9.37" } +substrate-wasm-builder = { version = "5.0.0-dev", git = "https://github.com/paritytech/substrate.git", optional = true, branch = "polkadot-v0.9.37" } [features] default = ["std"] std = [ - "frame-try-runtime?/std", - "frame-system-benchmarking?/std", - "frame-benchmarking?/std", - "codec/std", - "scale-info/std", - "frame-executive/std", - "frame-support/std", - "frame-system-rpc-runtime-api/std", - "frame-system/std", - "frame-try-runtime/std", - "pallet-aura/std", - "pallet-balances/std", - "pallet-grandpa/std", - "pallet-randomness-collective-flip/std", - "pallet-sudo/std", - "pallet-template/std", - "pallet-timestamp/std", - "pallet-transaction-payment-rpc-runtime-api/std", - "pallet-transaction-payment/std", - "sp-api/std", - "sp-block-builder/std", - "sp-consensus-aura/std", - "sp-core/std", - "sp-inherents/std", - "sp-offchain/std", - "sp-runtime/std", - "sp-session/std", - "sp-std/std", - "sp-transaction-pool/std", - "sp-version/std", - "substrate-wasm-builder", + "frame-try-runtime?/std", + "frame-system-benchmarking?/std", + "frame-benchmarking?/std", + "codec/std", + "scale-info/std", + "frame-executive/std", + "frame-support/std", + "frame-system-rpc-runtime-api/std", + "frame-system/std", + "frame-try-runtime/std", + "pallet-aura/std", + "pallet-balances/std", + "pallet-grandpa/std", + "pallet-randomness-collective-flip/std", + "pallet-sudo/std", + "pallet-template/std", + "pallet-timestamp/std", + "pallet-transaction-payment-rpc-runtime-api/std", + "pallet-transaction-payment/std", + "sp-api/std", + "sp-block-builder/std", + "sp-consensus-aura/std", + "sp-core/std", + "sp-inherents/std", + "sp-offchain/std", + "sp-runtime/std", + "sp-session/std", + "sp-std/std", + "sp-transaction-pool/std", + "sp-version/std", + "substrate-wasm-builder", + "pallet-permissions/std", + "pallet-spaces/std", + "pallet-roles/std", + "pallet-posts/std", + "pallet-space-follows/std", ] runtime-benchmarks = [ - "frame-benchmarking/runtime-benchmarks", - "frame-support/runtime-benchmarks", - "frame-system-benchmarking/runtime-benchmarks", - "frame-system/runtime-benchmarks", - "pallet-balances/runtime-benchmarks", - "pallet-grandpa/runtime-benchmarks", - "pallet-template/runtime-benchmarks", - "pallet-timestamp/runtime-benchmarks", - "sp-runtime/runtime-benchmarks", + "frame-benchmarking/runtime-benchmarks", + "frame-support/runtime-benchmarks", + "frame-system-benchmarking/runtime-benchmarks", + "frame-system/runtime-benchmarks", + "pallet-balances/runtime-benchmarks", + "pallet-grandpa/runtime-benchmarks", + "pallet-template/runtime-benchmarks", + "pallet-timestamp/runtime-benchmarks", + "sp-runtime/runtime-benchmarks", ] try-runtime = [ - "frame-try-runtime/try-runtime", - "frame-executive/try-runtime", - "frame-system/try-runtime", - "frame-support/try-runtime", - "pallet-aura/try-runtime", - "pallet-balances/try-runtime", - "pallet-grandpa/try-runtime", - "pallet-randomness-collective-flip/try-runtime", - "pallet-sudo/try-runtime", - "pallet-template/try-runtime", - "pallet-timestamp/try-runtime", - "pallet-transaction-payment/try-runtime", + "frame-try-runtime/try-runtime", + "frame-executive/try-runtime", + "frame-system/try-runtime", + "frame-support/try-runtime", + "pallet-aura/try-runtime", + "pallet-balances/try-runtime", + "pallet-grandpa/try-runtime", + "pallet-randomness-collective-flip/try-runtime", + "pallet-sudo/try-runtime", + "pallet-template/try-runtime", + "pallet-permissions/try-runtime", + "pallet-spaces/try-runtime", + "pallet-roles/try-runtime", + "pallet-space-follows/try-runtime", + "pallet-posts/try-runtime", + "pallet-timestamp/try-runtime", + "pallet-transaction-payment/try-runtime", ] diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 5722f9b..78be479 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -280,6 +280,56 @@ impl pallet_template::Config for Runtime { type RuntimeEvent = RuntimeEvent; } +use pallet_permissions::default_permissions::DefaultSpacePermissions; + +impl pallet_permissions::Config for Runtime { + type DefaultSpacePermissions = DefaultSpacePermissions; +} + +parameter_types! { + pub const MaxSpacesPerAccount: u32 = 4096; +} + +impl pallet_spaces::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Roles = Roles; + type SpaceFollows = SpaceFollows; + type IsAccountBlocked = ()/*Moderation*/; + type IsContentBlocked = ()/*Moderation*/; + type MaxSpacesPerAccount = MaxSpacesPerAccount; + type WeightInfo = pallet_spaces::weights::SubstrateWeight; +} + +parameter_types! { + pub const MaxUsersToProcessPerDeleteRole: u16 = 40; +} + +impl pallet_roles::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type MaxUsersToProcessPerDeleteRole = MaxUsersToProcessPerDeleteRole; + type SpacePermissionsProvider = Spaces; + type SpaceFollows = SpaceFollows; + type IsAccountBlocked = ()/*Moderation*/; + type IsContentBlocked = ()/*Moderation*/; + type WeightInfo = pallet_roles::weights::SubstrateWeight; +} + +parameter_types! { + pub const MaxCommentDepth: u32 = 10; +} + +impl pallet_posts::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type MaxCommentDepth = MaxCommentDepth; + type IsPostBlocked = ()/*Moderation*/; + type WeightInfo = pallet_posts::weights::SubstrateWeight; +} + +impl pallet_space_follows::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type WeightInfo = pallet_space_follows::weights::SubstrateWeight; +} + // Create the runtime by composing the FRAME pallets that were previously configured. construct_runtime!( pub struct Runtime @@ -298,6 +348,11 @@ construct_runtime!( Sudo: pallet_sudo, // Include the custom logic from the pallet-template in the runtime. TemplateModule: pallet_template, + Permissions: pallet_permissions, + Spaces: pallet_spaces, + Roles: pallet_roles, + SpaceFollows: pallet_space_follows, + Posts: pallet_posts, } ); From f5d16cbc2dad0e88f01f6448ba560df08be52064 Mon Sep 17 00:00:00 2001 From: Vlad Proshchavaiev <32250097+F3Joule@users.noreply.github.com> Date: Wed, 8 Mar 2023 11:51:51 +0200 Subject: [PATCH 03/13] Clean-up code Set-up specific rust version --- Cargo.lock | 26 +- Cargo.toml | 2 +- pallets/permissions/Cargo.toml | 39 -- .../permissions/src/default_permissions.rs | 61 -- pallets/permissions/src/lib.rs | 91 --- pallets/permissions/src/types.rs | 143 ---- pallets/posts/Cargo.toml | 50 -- pallets/posts/rpc/Cargo.toml | 43 -- pallets/posts/rpc/runtime-api/Cargo.toml | 35 - pallets/posts/rpc/runtime-api/src/lib.rs | 39 -- pallets/posts/rpc/src/lib.rs | 270 -------- pallets/posts/src/benchmarking.rs | 147 ----- pallets/posts/src/functions.rs | 337 ---------- pallets/posts/src/lib.rs | 485 -------------- pallets/posts/src/rpc.rs | 313 --------- pallets/posts/src/types.rs | 71 -- pallets/posts/src/weights.rs | 169 ----- pallets/posts/tests/Cargo.toml | 60 -- pallets/posts/tests/src/comments_tests.rs | 209 ------ pallets/posts/tests/src/lib.rs | 10 - pallets/posts/tests/src/mock.rs | 151 ----- pallets/posts/tests/src/post_tests.rs | 612 ------------------ pallets/posts/tests/src/shared_posts_tests.rs | 180 ------ pallets/posts/tests/src/tests_utils.rs | 488 -------------- pallets/roles/Cargo.toml | 57 -- pallets/roles/rpc/Cargo.toml | 51 -- pallets/roles/rpc/runtime-api/Cargo.toml | 43 -- pallets/roles/rpc/runtime-api/src/lib.rs | 18 - pallets/roles/rpc/src/lib.rs | 96 --- pallets/roles/src/benchmarking.rs | 146 ----- pallets/roles/src/functions.rs | 187 ------ pallets/roles/src/lib.rs | 490 -------------- pallets/roles/src/mock.rs | 345 ---------- pallets/roles/src/rpc.rs | 47 -- pallets/roles/src/tests.rs | 567 ---------------- pallets/roles/src/types.rs | 43 -- pallets/roles/src/weights.rs | 188 ------ pallets/space-follows/Cargo.toml | 40 -- pallets/space-follows/rpc/Cargo.toml | 49 -- .../space-follows/rpc/runtime-api/Cargo.toml | 41 -- .../space-follows/rpc/runtime-api/src/lib.rs | 16 - pallets/space-follows/rpc/src/lib.rs | 76 --- pallets/space-follows/src/benchmarking.rs | 52 -- pallets/space-follows/src/lib.rs | 170 ----- pallets/space-follows/src/rpc.rs | 17 - pallets/space-follows/src/weights.rs | 95 --- pallets/space-follows/tests/Cargo.toml | 58 -- pallets/space-follows/tests/src/lib.rs | 6 - pallets/space-follows/tests/src/mock.rs | 122 ---- pallets/space-follows/tests/src/tests.rs | 65 -- .../space-follows/tests/src/tests_utils.rs | 134 ---- pallets/spaces/Cargo.toml | 48 -- pallets/spaces/rpc/Cargo.toml | 51 -- pallets/spaces/rpc/runtime-api/Cargo.toml | 43 -- pallets/spaces/rpc/runtime-api/src/lib.rs | 32 - pallets/spaces/rpc/src/lib.rs | 195 ------ pallets/spaces/src/benchmarking.rs | 57 -- pallets/spaces/src/lib.rs | 434 ------------- pallets/spaces/src/rpc.rs | 142 ---- pallets/spaces/src/types.rs | 83 --- pallets/spaces/src/weights.rs | 91 --- pallets/spaces/tests/Cargo.toml | 58 -- pallets/spaces/tests/src/lib.rs | 6 - pallets/spaces/tests/src/mock.rs | 144 ----- pallets/spaces/tests/src/tests.rs | 345 ---------- pallets/spaces/tests/src/tests_utils.rs | 396 ------------ pallets/support/Cargo.toml | 35 - pallets/support/src/lib.rs | 256 -------- pallets/support/src/traits.rs | 7 - pallets/support/src/traits/common.rs | 27 - pallets/support/src/traits/moderation.rs | 51 -- pallets/template/Cargo.toml | 39 -- pallets/template/README.md | 1 - pallets/template/src/benchmarking.rs | 20 - pallets/template/src/lib.rs | 104 --- pallets/template/src/mock.rs | 59 -- pallets/template/src/tests.rs | 27 - runtime/Cargo.toml | 15 +- runtime/src/lib.rs | 12 +- scripts/init.sh | 5 +- 80 files changed, 16 insertions(+), 10017 deletions(-) delete mode 100644 pallets/permissions/Cargo.toml delete mode 100644 pallets/permissions/src/default_permissions.rs delete mode 100644 pallets/permissions/src/lib.rs delete mode 100644 pallets/permissions/src/types.rs delete mode 100644 pallets/posts/Cargo.toml delete mode 100644 pallets/posts/rpc/Cargo.toml delete mode 100644 pallets/posts/rpc/runtime-api/Cargo.toml delete mode 100644 pallets/posts/rpc/runtime-api/src/lib.rs delete mode 100644 pallets/posts/rpc/src/lib.rs delete mode 100644 pallets/posts/src/benchmarking.rs delete mode 100644 pallets/posts/src/functions.rs delete mode 100644 pallets/posts/src/lib.rs delete mode 100644 pallets/posts/src/rpc.rs delete mode 100644 pallets/posts/src/types.rs delete mode 100644 pallets/posts/src/weights.rs delete mode 100644 pallets/posts/tests/Cargo.toml delete mode 100644 pallets/posts/tests/src/comments_tests.rs delete mode 100644 pallets/posts/tests/src/lib.rs delete mode 100644 pallets/posts/tests/src/mock.rs delete mode 100644 pallets/posts/tests/src/post_tests.rs delete mode 100644 pallets/posts/tests/src/shared_posts_tests.rs delete mode 100644 pallets/posts/tests/src/tests_utils.rs delete mode 100644 pallets/roles/Cargo.toml delete mode 100644 pallets/roles/rpc/Cargo.toml delete mode 100644 pallets/roles/rpc/runtime-api/Cargo.toml delete mode 100644 pallets/roles/rpc/runtime-api/src/lib.rs delete mode 100644 pallets/roles/rpc/src/lib.rs delete mode 100644 pallets/roles/src/benchmarking.rs delete mode 100644 pallets/roles/src/functions.rs delete mode 100644 pallets/roles/src/lib.rs delete mode 100644 pallets/roles/src/mock.rs delete mode 100644 pallets/roles/src/rpc.rs delete mode 100644 pallets/roles/src/tests.rs delete mode 100644 pallets/roles/src/types.rs delete mode 100644 pallets/roles/src/weights.rs delete mode 100644 pallets/space-follows/Cargo.toml delete mode 100644 pallets/space-follows/rpc/Cargo.toml delete mode 100644 pallets/space-follows/rpc/runtime-api/Cargo.toml delete mode 100644 pallets/space-follows/rpc/runtime-api/src/lib.rs delete mode 100644 pallets/space-follows/rpc/src/lib.rs delete mode 100644 pallets/space-follows/src/benchmarking.rs delete mode 100644 pallets/space-follows/src/lib.rs delete mode 100644 pallets/space-follows/src/rpc.rs delete mode 100644 pallets/space-follows/src/weights.rs delete mode 100644 pallets/space-follows/tests/Cargo.toml delete mode 100644 pallets/space-follows/tests/src/lib.rs delete mode 100644 pallets/space-follows/tests/src/mock.rs delete mode 100644 pallets/space-follows/tests/src/tests.rs delete mode 100644 pallets/space-follows/tests/src/tests_utils.rs delete mode 100644 pallets/spaces/Cargo.toml delete mode 100644 pallets/spaces/rpc/Cargo.toml delete mode 100644 pallets/spaces/rpc/runtime-api/Cargo.toml delete mode 100644 pallets/spaces/rpc/runtime-api/src/lib.rs delete mode 100644 pallets/spaces/rpc/src/lib.rs delete mode 100644 pallets/spaces/src/benchmarking.rs delete mode 100644 pallets/spaces/src/lib.rs delete mode 100644 pallets/spaces/src/rpc.rs delete mode 100644 pallets/spaces/src/types.rs delete mode 100644 pallets/spaces/src/weights.rs delete mode 100644 pallets/spaces/tests/Cargo.toml delete mode 100644 pallets/spaces/tests/src/lib.rs delete mode 100644 pallets/spaces/tests/src/mock.rs delete mode 100644 pallets/spaces/tests/src/tests.rs delete mode 100644 pallets/spaces/tests/src/tests_utils.rs delete mode 100644 pallets/support/Cargo.toml delete mode 100644 pallets/support/src/lib.rs delete mode 100644 pallets/support/src/traits.rs delete mode 100644 pallets/support/src/traits/common.rs delete mode 100644 pallets/support/src/traits/moderation.rs delete mode 100644 pallets/template/Cargo.toml delete mode 100644 pallets/template/README.md delete mode 100644 pallets/template/src/benchmarking.rs delete mode 100644 pallets/template/src/lib.rs delete mode 100644 pallets/template/src/mock.rs delete mode 100644 pallets/template/src/tests.rs diff --git a/Cargo.lock b/Cargo.lock index 20eb404..c48141d 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4249,6 +4249,7 @@ dependencies = [ [[package]] name = "pallet-permissions" version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" dependencies = [ "frame-support", "frame-system", @@ -4263,6 +4264,7 @@ dependencies = [ [[package]] name = "pallet-posts" version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" dependencies = [ "frame-benchmarking", "frame-support", @@ -4296,19 +4298,15 @@ dependencies = [ [[package]] name = "pallet-roles" version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" dependencies = [ "frame-benchmarking", "frame-support", "frame-system", - "pallet-balances", "pallet-permissions", - "pallet-spaces", "pallet-timestamp", "parity-scale-codec", "scale-info", - "serde", - "sp-core", - "sp-io", "sp-runtime", "sp-std", "subsocial-support", @@ -4338,6 +4336,7 @@ dependencies = [ [[package]] name = "pallet-space-follows" version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" dependencies = [ "frame-benchmarking", "frame-support", @@ -4352,6 +4351,7 @@ dependencies = [ [[package]] name = "pallet-spaces" version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" dependencies = [ "frame-benchmarking", "frame-support", @@ -4380,20 +4380,6 @@ dependencies = [ "sp-std", ] -[[package]] -name = "pallet-template" -version = "4.0.0-dev" -dependencies = [ - "frame-benchmarking", - "frame-support", - "frame-system", - "parity-scale-codec", - "scale-info", - "sp-core", - "sp-io", - "sp-runtime", -] - [[package]] name = "pallet-timestamp" version = "4.0.0-dev" @@ -7612,6 +7598,7 @@ dependencies = [ [[package]] name = "subsocial-support" version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" dependencies = [ "frame-support", "frame-system", @@ -9432,7 +9419,6 @@ dependencies = [ "pallet-space-follows", "pallet-spaces", "pallet-sudo", - "pallet-template", "pallet-timestamp", "pallet-transaction-payment", "pallet-transaction-payment-rpc-runtime-api", diff --git a/Cargo.toml b/Cargo.toml index c1f1230..1997451 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [workspace] members = [ "node", - "pallets/*", +# "pallets/*", "runtime", ] [profile.release] diff --git a/pallets/permissions/Cargo.toml b/pallets/permissions/Cargo.toml deleted file mode 100644 index 64931f9..0000000 --- a/pallets/permissions/Cargo.toml +++ /dev/null @@ -1,39 +0,0 @@ -[package] -name = 'pallet-permissions' -version = '0.1.7' -authors = ['DappForce '] -edition = '2021' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Permission management pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[features] -default = ['std'] -std = [ - 'serde', - 'codec/std', - 'scale-info/std', - 'sp-runtime/std', - 'frame-support/std', - 'frame-system/std', - 'sp-std/std', - 'subsocial-support/std', -] -try-runtime = ["frame-support/try-runtime"] - -[dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } -serde = { features = ['derive'], optional = true, version = '1.0.152' } - -# Local dependencies -subsocial-support = { default-features = false, path = '../support' } - -# Substrate dependencies -frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } diff --git a/pallets/permissions/src/default_permissions.rs b/pallets/permissions/src/default_permissions.rs deleted file mode 100644 index e0e758d..0000000 --- a/pallets/permissions/src/default_permissions.rs +++ /dev/null @@ -1,61 +0,0 @@ -use crate::{SpacePermission as SP, SpacePermissions}; - -use frame_support::parameter_types; -use sp_std::vec; - -parameter_types! { - pub DefaultSpacePermissions: SpacePermissions = SpacePermissions { - - // No permissions disabled by default - none: None, - - everyone: Some(vec![ - SP::UpdateOwnSubspaces, - SP::DeleteOwnSubspaces, - SP::HideOwnSubspaces, - - SP::UpdateOwnPosts, - SP::DeleteOwnPosts, - SP::HideOwnPosts, - - SP::CreateComments, - SP::UpdateOwnComments, - SP::DeleteOwnComments, - SP::HideOwnComments, - - SP::Upvote, - SP::Downvote, - SP::Share, - ].into_iter().collect()), - - // Followers can do everything that everyone else can. - follower: None, - - space_owner: Some(vec![ - SP::ManageRoles, - SP::RepresentSpaceInternally, - SP::RepresentSpaceExternally, - SP::OverrideSubspacePermissions, - SP::OverridePostPermissions, - - SP::CreateSubspaces, - SP::CreatePosts, - - SP::UpdateSpace, - SP::UpdateAnySubspace, - SP::UpdateAnyPost, - - SP::DeleteAnySubspace, - SP::DeleteAnyPost, - - SP::HideAnySubspace, - SP::HideAnyPost, - SP::HideAnyComment, - - SP::SuggestEntityStatus, - SP::UpdateEntityStatus, - - SP::UpdateSpaceSettings, - ].into_iter().collect()), - }; -} diff --git a/pallets/permissions/src/lib.rs b/pallets/permissions/src/lib.rs deleted file mode 100644 index 7f87ff7..0000000 --- a/pallets/permissions/src/lib.rs +++ /dev/null @@ -1,91 +0,0 @@ -#![cfg_attr(not(feature = "std"), no_std)] - -pub use pallet::*; - -#[cfg(feature = "std")] -use serde::{Deserialize, Serialize}; - -use sp_std::collections::btree_set::BTreeSet; - -pub mod default_permissions; -mod types; - -pub use types::*; - -#[frame_support::pallet] -pub mod pallet { - use super::*; - - use frame_support::pallet_prelude::*; - - #[pallet::pallet] - pub struct Pallet(_); - - #[pallet::config] - pub trait Config: frame_system::Config { - #[pallet::constant] - type DefaultSpacePermissions: Get; - } - - impl Pallet { - fn get_overrides_or_defaults( - overrides: Option, - defaults: Option, - ) -> Option { - if overrides.is_some() { - overrides - } else { - defaults - } - } - - fn resolve_space_perms(space_perms: Option) -> SpacePermissions { - let defaults = T::DefaultSpacePermissions::get(); - let overrides = space_perms.unwrap_or_default(); - - SpacePermissions { - none: Self::get_overrides_or_defaults(overrides.none, defaults.none), - everyone: Self::get_overrides_or_defaults(overrides.everyone, defaults.everyone), - follower: Self::get_overrides_or_defaults(overrides.follower, defaults.follower), - space_owner: Self::get_overrides_or_defaults( - overrides.space_owner, - defaults.space_owner, - ), - } - } - - pub fn has_user_a_space_permission( - ctx: SpacePermissionsContext, - permission: SpacePermission, - ) -> Option { - let perms_by_role = Self::resolve_space_perms(ctx.space_perms); - - // Check if this permission is forbidden: - if permission.is_present_in_role(perms_by_role.none) { - return Some(false) - } - - let is_space_owner = ctx.is_space_owner; - let is_follower = is_space_owner || ctx.is_space_follower; - - if permission.is_present_in_role(perms_by_role.everyone) || - is_follower && permission.is_present_in_role(perms_by_role.follower) || - is_space_owner && permission.is_present_in_role(perms_by_role.space_owner) - { - return Some(true) - } - - None - } - - pub fn override_permissions(mut overrides: SpacePermissions) -> SpacePermissions { - overrides.none = overrides.none.map(|mut none_permissions_set| { - none_permissions_set - .extend(T::DefaultSpacePermissions::get().none.unwrap_or_default()); - none_permissions_set - }); - - overrides - } - } -} diff --git a/pallets/permissions/src/types.rs b/pallets/permissions/src/types.rs deleted file mode 100644 index a05b087..0000000 --- a/pallets/permissions/src/types.rs +++ /dev/null @@ -1,143 +0,0 @@ -use codec::{Decode, Encode}; -use frame_support::dispatch::{DispatchError, DispatchResult}; -use scale_info::TypeInfo; -use sp_runtime::RuntimeDebug; - -use subsocial_support::{SpaceId, SpacePermissionsInfo, User}; - -use super::*; - -pub type SpacePermissionsInfoOf = -SpacePermissionsInfo<::AccountId, SpacePermissions>; - -#[derive(Encode, Decode, Ord, PartialOrd, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] -pub enum SpacePermission { - /// Create, update, delete, grant and revoke roles in this space. - ManageRoles, - - /// Act on behalf of this space within this space. - RepresentSpaceInternally, - /// Act on behalf of this space outside of this space. - RepresentSpaceExternally, - - /// Update this space. - UpdateSpace, - - // Related to subspaces in this space: - CreateSubspaces, - UpdateOwnSubspaces, - DeleteOwnSubspaces, - HideOwnSubspaces, - - UpdateAnySubspace, - DeleteAnySubspace, - HideAnySubspace, - - // Related to posts in this space: - CreatePosts, - UpdateOwnPosts, - DeleteOwnPosts, - HideOwnPosts, - - UpdateAnyPost, - DeleteAnyPost, - HideAnyPost, - - // Related to comments in this space: - CreateComments, - UpdateOwnComments, - DeleteOwnComments, - HideOwnComments, - - // NOTE: It was made on purpose that it's not possible to update or delete not own comments. - // Instead it's possible to allow to hide and block comments. - HideAnyComment, - - /// Upvote any post or comment in this space. - Upvote, - /// Downvote any post or comment in this space. - Downvote, - /// Share any post or comment from this space to another outer space. - Share, - - /// Override permissions per subspace in this space. - OverrideSubspacePermissions, - /// Override permissions per post in this space. - OverridePostPermissions, - - // Related to the moderation pallet: - /// Suggest new entity status in space (whether it's blocked or allowed) - SuggestEntityStatus, - /// Update entity status in space - UpdateEntityStatus, - - // Related to space settings: - /// Allows to update space settings across different pallets. - UpdateSpaceSettings, -} - -pub type SpacePermissionSet = BTreeSet; - -/// These are a set of built-in roles which can be given different permissions within a given space. -/// For example: everyone can comment (`CreateComments`), but only followers can post -/// (`CreatePosts`). -#[derive(Encode, Decode, Default, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] -pub struct SpacePermissions { - /// None represents a set of permissions which is not capable of being performed by anyone. - /// For example, if you want to create a space similar to Twitter, you would set the - /// permissions for `UpdateOwnPosts`, `UpdateOwnComments`, and `Downvote` to `none`. - pub none: Option, - - /// Everyone represents a set of permissions which are capable of being performed by every - /// account in a given space. - pub everyone: Option, - - /// Follower represents a set of permissions which are capable of being performed by every - /// account that follows a given space. - pub follower: Option, - - /// Space owner represents a set of permissions which are capable of being performed by an - /// account that is a current owner of a given space. - pub space_owner: Option, -} - -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -pub struct SpacePermissionsContext { - pub space_id: SpaceId, - pub is_space_owner: bool, - pub is_space_follower: bool, - pub space_perms: Option, -} - -impl SpacePermission { - pub(super) fn is_present_in_role(&self, perms_opt: Option) -> bool { - if let Some(perms) = perms_opt { - if perms.contains(self) { - return true - } - } - false - } -} - -pub trait PermissionChecker { - type AccountId; - - fn ensure_user_has_space_permission( - user: User, - ctx: SpacePermissionsContext, - permission: SpacePermission, - error: DispatchError, - ) -> DispatchResult; - - fn ensure_account_has_space_permission( - account: Self::AccountId, - ctx: SpacePermissionsContext, - permission: SpacePermission, - error: DispatchError, - ) -> DispatchResult { - Self::ensure_user_has_space_permission(User::Account(account), ctx, permission, error) - } -} diff --git a/pallets/posts/Cargo.toml b/pallets/posts/Cargo.toml deleted file mode 100644 index f25f9a5..0000000 --- a/pallets/posts/Cargo.toml +++ /dev/null @@ -1,50 +0,0 @@ -[package] -name = 'pallet-posts' -version = '0.1.7' -authors = ['DappForce '] -edition = '2021' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Post management pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[features] -default = ['std'] -runtime-benchmarks = ['frame-benchmarking/runtime-benchmarks'] -std = [ - 'serde', - 'codec/std', - 'scale-info/std', - 'frame-benchmarking/std', - 'frame-support/std', - 'frame-system/std', - 'pallet-timestamp/std', - 'sp-runtime/std', - 'sp-std/std', - 'pallet-permissions/std', - 'pallet-space-follows/std', - 'pallet-spaces/std', - 'subsocial-support/std', -] -try-runtime = ['frame-support/try-runtime'] - -[dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } -serde = { features = ['derive'], optional = true, version = '1.0.152' } - -# Local dependencies -pallet-permissions = { default-features = false, path = '../permissions' } -pallet-space-follows = { default-features = false, path = '../space-follows' } -pallet-spaces = { default-features = false, path = '../spaces' } -subsocial-support = { default-features = false, path = '../support' } - -# Substrate dependencies -frame-benchmarking = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false, optional = true } -frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } diff --git a/pallets/posts/rpc/Cargo.toml b/pallets/posts/rpc/Cargo.toml deleted file mode 100644 index 69ef41e..0000000 --- a/pallets/posts/rpc/Cargo.toml +++ /dev/null @@ -1,43 +0,0 @@ -[package] -name = 'posts-rpc' -version = '0.7.3' -authors = ['DappForce '] -edition = '2018' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'RPC methods for the posts pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[dependencies] -codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false, features = ["derive"] } -serde = { features = ['derive'], optional = true, version = '1.0.119' } - -jsonrpc-core = '18.0.0' -jsonrpc-core-client = '18.0.0' -jsonrpc-derive = '18.0.0' - -# Local dependencies -pallet-posts = { default-features = false, path = '..' } -pallet-utils = { default-features = false, path = '../../utils' } - -# Custom Runtime API -posts-runtime-api = { default-features = false, path = 'runtime-api' } - -# Substrate dependencies -sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-blockchain = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-rpc = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } - -[features] -default = ['std'] -std = [ - 'serde', - 'sp-runtime/std', - 'sp-api/std', - 'posts-runtime-api/std', - 'pallet-utils/std', - 'pallet-posts/std', -] diff --git a/pallets/posts/rpc/runtime-api/Cargo.toml b/pallets/posts/rpc/runtime-api/Cargo.toml deleted file mode 100644 index e23f98b..0000000 --- a/pallets/posts/rpc/runtime-api/Cargo.toml +++ /dev/null @@ -1,35 +0,0 @@ -[package] -name = 'posts-runtime-api' -version = '0.7.3' -authors = ['DappForce '] -edition = '2018' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Runtime API definition for the posts pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[dependencies] -codec = { package = "parity-scale-codec", version = "2.0.0", default-features = false, features = ["derive"] } -serde = { features = ['derive'], optional = true, version = '1.0.119' } - -# Local dependencies -pallet-posts = { default-features = false, path = '../..' } -pallet-utils = { default-features = false, path = '../../../utils' } - -# Substrate dependencies -sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } - -[features] -default = ['std'] -std = [ - 'serde', - 'sp-api/std', - 'sp-std/std', - 'sp-runtime/std', - 'pallet-utils/std', - 'pallet-posts/std', -] diff --git a/pallets/posts/rpc/runtime-api/src/lib.rs b/pallets/posts/rpc/runtime-api/src/lib.rs deleted file mode 100644 index fbe359e..0000000 --- a/pallets/posts/rpc/runtime-api/src/lib.rs +++ /dev/null @@ -1,39 +0,0 @@ -#![cfg_attr(not(feature = "std"), no_std)] - -use codec::Codec; -use sp_std::collections::btree_map::BTreeMap; -use sp_std::vec::Vec; - -use pallet_posts::rpc::{FlatPost, FlatPostKind, RepliesByPostId}; -use pallet_utils::{PostId, SpaceId}; - -sp_api::decl_runtime_apis! { - pub trait PostsApi where - AccountId: Codec, - BlockNumber: Codec - { - fn get_next_post_id() -> PostId; - - fn get_posts_by_ids(post_ids: Vec, offset: u64, limit: u16) -> Vec>; - - fn get_public_posts(kind_filter: Vec, offset: u64, limit: u16) -> Vec>; - - fn get_public_posts_by_space_id(space_id: SpaceId, offset: u64, limit: u16) -> Vec>; - - fn get_unlisted_posts_by_space_id(space_id: SpaceId, offset: u64, limit: u16) -> Vec>; - - fn get_public_post_ids_by_space_id(space_id: SpaceId) -> Vec; - - fn get_unlisted_post_ids_by_space_id(space_id: SpaceId) -> Vec; - - fn get_reply_ids_by_parent_id(parent_id: PostId) -> Vec; - - fn get_reply_ids_by_parent_ids(parent_ids: Vec) -> BTreeMap>; - - fn get_replies_by_parent_id(parent_id: PostId, offset: u64, limit: u16) -> Vec>; - - fn get_replies_by_parent_ids(parent_ids: Vec, offset: u64, limit: u16) -> RepliesByPostId; - - fn get_feed(account: AccountId, offset: u64, limit: u16) -> Vec>; - } -} diff --git a/pallets/posts/rpc/src/lib.rs b/pallets/posts/rpc/src/lib.rs deleted file mode 100644 index 0028f40..0000000 --- a/pallets/posts/rpc/src/lib.rs +++ /dev/null @@ -1,270 +0,0 @@ -use std::{sync::Arc, collections::BTreeMap}; -use codec::Codec; -use sp_blockchain::HeaderBackend; -use sp_runtime::{generic::BlockId, traits::Block as BlockT}; -use jsonrpc_core::Result; -use jsonrpc_derive::rpc; -use sp_api::ProvideRuntimeApi; - -use pallet_posts::rpc::{FlatPost, FlatPostKind, RepliesByPostId}; -use pallet_utils::{PostId, SpaceId, rpc::map_rpc_error}; -pub use posts_runtime_api::PostsApi as PostsRuntimeApi; - -#[rpc] -pub trait PostsApi { - #[rpc(name = "posts_getPostsByIds")] - fn get_posts_by_ids( - &self, - at: Option, - post_ids: Vec, - offset: u64, - limit: u16, - ) -> Result>>; - - #[rpc(name = "posts_getPublicPosts")] - fn get_public_posts( - &self, - at: Option, - kind_filter: Vec, - start_id: u64, - limit: u16 - ) -> Result>>; - - #[rpc(name = "posts_getPublicPostsBySpaceId")] - fn get_public_posts_by_space_id( - &self, - at: Option, - space_id: SpaceId, - offset: u64, - limit: u16, - ) -> Result>>; - - #[rpc(name = "posts_getUnlistedPostsBySpaceId")] - fn get_unlisted_posts_by_space_id( - &self, - at: Option, - space_id: SpaceId, - offset: u64, - limit: u16, - ) -> Result>>; - - #[rpc(name = "posts_getReplyIdsByParentId")] - fn get_reply_ids_by_parent_id( - &self, - at: Option, - post_id: PostId, - ) -> Result>; - - #[rpc(name = "posts_getReplyIdsByParentIds")] - fn get_reply_ids_by_parent_ids( - &self, - at: Option, - post_ids: Vec, - ) -> Result>>; - - #[rpc(name = "posts_getRepliesByParentId")] - fn get_replies_by_parent_id( - &self, - at: Option, - parent_id: PostId, - offset: u64, - limit: u16, - ) -> Result>>; - - #[rpc(name = "posts_getRepliesByParentIds")] - fn get_replies_by_parent_ids( - &self, - at: Option, - parent_ids: Vec, - offset: u64, - limit: u16, - ) -> Result>; - - #[rpc(name = "posts_getUnlistedPostIdsBySpaceId")] - fn get_unlisted_post_ids_by_space_id( - &self, - at: Option, - space_id: SpaceId, - ) -> Result>; - - #[rpc(name = "posts_getPublicPostIdsBySpaceId")] - fn get_public_post_ids_by_space_id( - &self, - at: Option, - space_id: SpaceId, - ) -> Result>; - - #[rpc(name = "posts_nextPostId")] - fn get_next_post_id(&self, at: Option) -> Result; - - #[rpc(name = "posts_getFeed")] - fn get_feed( - &self, - at: Option, - account: AccountId, - offset: u64, - limit: u16, - ) -> Result>>; -} - -pub struct Posts { - client: Arc, - _marker: std::marker::PhantomData, -} - -impl Posts { - pub fn new(client: Arc) -> Self { - Self { - client, - _marker: Default::default(), - } - } -} - -impl PostsApi<::Hash, AccountId, BlockNumber> - for Posts -where - Block: BlockT, - AccountId: Codec, - BlockNumber: Codec, - C: Send + Sync + 'static + ProvideRuntimeApi + HeaderBackend, - C::Api: PostsRuntimeApi, -{ - fn get_posts_by_ids( - &self, - at: Option<::Hash>, - post_ids: Vec, - offset: u64, - limit: u16, - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_posts_by_ids(&at, post_ids, offset, limit); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_public_posts( - &self, - at: Option<::Hash>, - kind_filter: Vec, - start_id: u64, - limit: u16 - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_public_posts(&at, kind_filter, start_id, limit); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_public_posts_by_space_id( - &self, - at: Option<::Hash>, - space_id: u64, - offset: u64, - limit: u16, - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_public_posts_by_space_id(&at, space_id, offset, limit); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_unlisted_posts_by_space_id( - &self, - at: Option<::Hash>, - space_id: u64, - offset: u64, - limit: u16, - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_unlisted_posts_by_space_id(&at, space_id, offset, limit); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_reply_ids_by_parent_id(&self, at: Option<::Hash>, parent_id: PostId) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_reply_ids_by_parent_id(&at, parent_id); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_reply_ids_by_parent_ids(&self, at: Option<::Hash>, parent_ids: Vec) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_reply_ids_by_parent_ids(&at, parent_ids); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_replies_by_parent_id( - &self, - at: Option<::Hash>, - parent_id: PostId, - offset: u64, - limit: u16 - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_replies_by_parent_id(&at, parent_id, offset, limit); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_replies_by_parent_ids( - &self, - at: Option<::Hash>, - parent_ids: Vec, - offset: u64, - limit: u16 - ) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_replies_by_parent_ids(&at, parent_ids, offset, limit); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_unlisted_post_ids_by_space_id(&self, at: Option<::Hash>, space_id: u64) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_unlisted_post_ids_by_space_id(&at, space_id); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_public_post_ids_by_space_id(&self, at: Option<::Hash>, space_id: u64) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_public_post_ids_by_space_id(&at, space_id); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_next_post_id(&self, at: Option<::Hash>) -> Result { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_next_post_id(&at); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_feed( - &self, - at: Option<::Hash>, - account: AccountId, - offset: u64, - limit: u16 - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_feed(&at, account, offset, limit); - runtime_api_result.map_err(map_rpc_error) - } -} diff --git a/pallets/posts/src/benchmarking.rs b/pallets/posts/src/benchmarking.rs deleted file mode 100644 index 1a29291..0000000 --- a/pallets/posts/src/benchmarking.rs +++ /dev/null @@ -1,147 +0,0 @@ -#![cfg(feature = "runtime-benchmarks")] - -use super::*; -use frame_benchmarking::{benchmarks, whitelisted_caller}; -use frame_support::dispatch::DispatchError; -use frame_system::RawOrigin; -use pallet_spaces::types::Space; -use subsocial_support::Content; - -fn create_dummy_space( - origin: RawOrigin, -) -> Result, DispatchError> { - let space_id = pallet_spaces::NextSpaceId::::get(); - - pallet_spaces::Pallet::::create_space(origin.into(), Content::None, None)?; - - let space = pallet_spaces::SpaceById::::get(space_id) - .ok_or(DispatchError::Other("Space not found"))?; - - Ok(space) -} - -fn create_dummy_post( - origin: RawOrigin, - space: Space, -) -> Result, DispatchError> { - let post_id = NextPostId::::get(); - - Pallet::::create_post( - origin.into(), - Some(space.id), - PostExtension::RegularPost, - Content::None, - )?; - - let post = PostById::::get(post_id).ok_or(DispatchError::Other("Post wasn't created"))?; - - Ok(post) -} - -fn create_dummy_reply( - origin: RawOrigin, - space: Space, - post: Post, -) -> Result, DispatchError> { - let post_id = NextPostId::::get(); - - Pallet::::create_post( - origin.into(), - Some(space.id), - PostExtension::Comment(Comment { parent_id: None, root_post_id: post.id }), - Content::None, - )?; - - let post = PostById::::get(post_id).ok_or(DispatchError::Other("Reply wasn't created"))?; - - Ok(post) -} - -benchmarks! { - create_post__regular { - let origin = RawOrigin::Signed(whitelisted_caller()); - let space = create_dummy_space::(origin.clone())?; - let post_id = NextPostId::::get(); - - }: create_post(origin, Some(space.id), PostExtension::RegularPost, Content::None) - verify { - let post = PostById::::get(post_id) - .ok_or(DispatchError::Other("Post wasn't created"))?; - - ensure!(post.space_id == Some(space.id), "Post wasn't created in the right space"); - ensure!(post.extension == PostExtension::RegularPost, "Post wasn't created with the right extension"); - } - - create_post__shared { - let origin = RawOrigin::Signed(whitelisted_caller()); - let space = create_dummy_space::(origin.clone())?; - let original_post = create_dummy_post::(origin.clone(), space.clone())?; - let post_id = NextPostId::::get(); - - }: create_post(origin, Some(space.id), PostExtension::SharedPost(original_post.id), Content::None) - verify { - let post = PostById::::get(post_id) - .ok_or(DispatchError::Other("Post wasn't created"))?; - - ensure!(post.space_id == Some(space.id), "Post wasn't created in the right space"); - ensure!(post.extension == PostExtension::SharedPost(original_post.id), "Post wasn't created with the right extension"); - } - - create_post__comment { - let origin = RawOrigin::Signed(whitelisted_caller()); - let space = create_dummy_space::(origin.clone())?; - let original_post = create_dummy_post::(origin.clone(), space.clone())?; - let reply = create_dummy_reply::(origin.clone(), space.clone(), original_post.clone())?; - let post_id = NextPostId::::get(); - - let ext = PostExtension::Comment(Comment { - parent_id: Some(reply.id), - root_post_id: original_post.id, - }); - }: create_post(origin, Some(space.id), ext, Content::None) - verify { - let post = PostById::::get(post_id) - .ok_or(DispatchError::Other("Reply wasn't created"))?; - - ensure!(post.space_id == Some(space.id), "Reply wasn't created in the right space"); - ensure!(post.extension == ext, "Post wasn't created with the right extension"); - } - - - update_post { - let origin = RawOrigin::Signed(whitelisted_caller()); - let space = create_dummy_space::(origin.clone())?; - let post = create_dummy_post::(origin.clone(), space.clone())?; - let reply = create_dummy_reply::(origin.clone(), space, post.clone())?; - - let new_content = Content::IPFS(b"Qme7ss3ARVgxv6rXqVPiikMJ8u2NLgmgszg13pYrDKEoiu".to_vec()); - - let update = PostUpdate { - hidden: Some(true), - content: Some(new_content.clone()), - space_id: None, - }; - }: update_post(origin, reply.id, update) - verify { - let updated_post = PostById::::get(reply.id) - .ok_or(DispatchError::Other("Post wasn't found"))?; - - ensure!(updated_post != post, "Post wasn't updated"); - ensure!(updated_post.hidden, "Post hidden status wasn't updated"); - ensure!(updated_post.content == new_content, "Post content wasn't updated"); - } - - move_post { - let origin = RawOrigin::Signed(whitelisted_caller()); - let space = create_dummy_space::(origin.clone())?; - let post = create_dummy_post::(origin.clone(), space)?; - - let new_space = create_dummy_space::(origin.clone())?; - }: move_post(origin, post.id, Some(new_space.id)) - verify { - let moved_post = PostById::::get(post.id) - .ok_or(DispatchError::Other("Post wasn't found"))?; - - ensure!(moved_post.space_id == Some(new_space.id), "Post wasn't moved"); - } -} diff --git a/pallets/posts/src/functions.rs b/pallets/posts/src/functions.rs deleted file mode 100644 index 2e0efff..0000000 --- a/pallets/posts/src/functions.rs +++ /dev/null @@ -1,337 +0,0 @@ -use frame_support::dispatch::DispatchResult; -use sp_runtime::traits::Saturating; - -use subsocial_support::{remove_from_vec, SpaceId}; - -use super::*; - -impl Post { - pub fn new( - id: PostId, - created_by: T::AccountId, - space_id_opt: Option, - extension: PostExtension, - content: Content, - ) -> Self { - Post { - id, - created: new_who_and_when::(created_by.clone()), - edited: false, - owner: created_by, - extension, - space_id: space_id_opt, - content, - hidden: false, - upvotes_count: 0, - downvotes_count: 0, - } - } - - pub fn ensure_owner(&self, account: &T::AccountId) -> DispatchResult { - ensure!(self.is_owner(account), Error::::NotAPostOwner); - Ok(()) - } - - pub fn is_owner(&self, account: &T::AccountId) -> bool { - self.owner == *account - } - - pub fn is_root_post(&self) -> bool { - !self.is_comment() - } - - pub fn is_regular_post(&self) -> bool { - matches!(self.extension, PostExtension::RegularPost) - } - - pub fn is_comment(&self) -> bool { - matches!(self.extension, PostExtension::Comment(_)) - } - - pub fn is_shared_post(&self) -> bool { - matches!(self.extension, PostExtension::SharedPost(_)) - } - - pub fn get_comment_ext(&self) -> Result { - match self.extension { - PostExtension::Comment(comment_ext) => Ok(comment_ext), - _ => Err(Error::::NotComment.into()), - } - } - - pub fn get_original_post_id(&self) -> Result { - match self.extension { - PostExtension::SharedPost(original_post_id) => Ok(original_post_id), - _ => Err(Error::::NotASharedPost.into()), - } - } - - pub fn get_root_post(&self) -> Result, DispatchError> { - match self.extension { - PostExtension::RegularPost | PostExtension::SharedPost(_) => Ok(self.clone()), - PostExtension::Comment(comment) => Pallet::::require_post(comment.root_post_id), - } - } - - pub fn get_space_id(&self) -> Result { - Self::try_get_space_id(self).ok_or_else(|| Error::::PostHasNoSpaceId.into()) - } - - pub fn try_get_space_id(&self) -> Option { - if let Ok(root_post) = self.get_root_post() { - return root_post.space_id - } - - None - } - - pub fn get_space(&self) -> Result, DispatchError> { - let root_post = self.get_root_post()?; - let space_id = root_post.space_id.ok_or(Error::::PostHasNoSpaceId)?; - Spaces::require_space(space_id) - } - - pub fn try_get_space(&self) -> Option> { - if let Ok(root_post) = self.get_root_post() { - return root_post.space_id.and_then(|space_id| Spaces::require_space(space_id).ok()) - } - - None - } - - pub fn try_get_parent_id(&self) -> Option { - match self.extension { - PostExtension::Comment(comment_ext) => comment_ext.parent_id, - _ => None, - } - } - - pub fn inc_upvotes(&mut self) { - self.upvotes_count.saturating_inc(); - } - - pub fn dec_upvotes(&mut self) { - self.upvotes_count.saturating_dec(); - } - - pub fn inc_downvotes(&mut self) { - self.downvotes_count.saturating_inc(); - } - - pub fn dec_downvotes(&mut self) { - self.downvotes_count.saturating_dec(); - } - - pub fn is_public(&self) -> bool { - !self.hidden && self.content.is_some() - } - - pub fn is_unlisted(&self) -> bool { - !self.is_public() - } -} - -impl Pallet { - pub fn ensure_account_can_update_post( - editor: &T::AccountId, - post: &Post, - space: &Space, - ) -> DispatchResult { - let is_owner = post.is_owner(editor); - let is_comment = post.is_comment(); - - let permission_to_check: SpacePermission; - let permission_error: DispatchError; - - if is_comment { - if is_owner { - permission_to_check = SpacePermission::UpdateOwnComments; - permission_error = Error::::NoPermissionToUpdateOwnComments.into(); - } else { - fail!(Error::::NotACommentAuthor); - } - } else { - // Not a comment - - if is_owner { - permission_to_check = SpacePermission::UpdateOwnPosts; - permission_error = Error::::NoPermissionToUpdateOwnPosts.into(); - } else { - permission_to_check = SpacePermission::UpdateAnyPost; - permission_error = Error::::NoPermissionToUpdateAnyPost.into(); - } - } - - Spaces::ensure_account_has_space_permission( - editor.clone(), - space, - permission_to_check, - permission_error, - ) - } - - /// Check that there is a `Post` with such `post_id` in the storage - /// or return`PostNotFound` error. - pub fn ensure_post_exists(post_id: PostId) -> DispatchResult { - ensure!(PostById::::contains_key(post_id), Error::::PostNotFound); - Ok(()) - } - - /// Get `Post` by id from the storage or return `PostNotFound` error. - pub fn require_post(post_id: SpaceId) -> Result, DispatchError> { - Ok(Self::post_by_id(post_id).ok_or(Error::::PostNotFound)?) - } - - pub fn is_root_post_hidden(post_id: PostId) -> Result { - let post = Self::require_post(post_id)?; - let root_post = post.get_root_post()?; - Ok(root_post.hidden) - } - - pub fn is_root_post_visible(post_id: PostId) -> Result { - Self::is_root_post_hidden(post_id).map(|v| !v) - } - - pub fn mutate_post_by_id)>( - post_id: PostId, - f: F, - ) -> Result, DispatchError> { - PostById::::mutate(post_id, |post_opt| { - if let Some(ref mut post) = post_opt.clone() { - f(post); - *post_opt = Some(post.clone()); - - return Ok(post.clone()) - } - - Err(Error::::PostNotFound.into()) - }) - } - - // TODO refactor to a tail recursion - /// Get all post ancestors (parent_id) including this post - pub fn get_post_ancestors(post_id: PostId) -> Vec> { - let mut ancestors: Vec> = Vec::new(); - - if let Some(post) = Self::post_by_id(post_id) { - ancestors.push(post.clone()); - if let Some(parent_id) = post.get_comment_ext().ok().unwrap().parent_id { - ancestors.extend(Self::get_post_ancestors(parent_id).iter().cloned()); - } - } - - ancestors - } - - pub(crate) fn create_comment( - new_post_id: PostId, - comment_ext: Comment, - root_post_id: PostId, - ) -> DispatchResult { - let mut commented_post_id = root_post_id; - - if let Some(parent_id) = comment_ext.parent_id { - let parent_comment = - Self::post_by_id(parent_id).ok_or(Error::::UnknownParentComment)?; - - ensure!(parent_comment.is_comment(), Error::::NotACommentByParentId); - - let ancestors = Self::get_post_ancestors(parent_id); - ensure!( - ancestors.len() < T::MaxCommentDepth::get() as usize, - Error::::MaxCommentDepthReached - ); - - commented_post_id = parent_id; - } - - ReplyIdsByPostId::::mutate(commented_post_id, |reply_ids| reply_ids.push(new_post_id)); - - Ok(()) - } - - pub(crate) fn create_shared_post( - creator: &T::AccountId, - new_post_id: PostId, - original_post_id: PostId, - ) -> DispatchResult { - let original_post = - &mut Self::post_by_id(original_post_id).ok_or(Error::::OriginalPostNotFound)?; - - ensure!(!original_post.is_shared_post(), Error::::CannotShareSharedPost); - - // Check if it's allowed to share a post from the space of original post. - Spaces::ensure_account_has_space_permission( - creator.clone(), - &original_post.get_space()?, - SpacePermission::Share, - Error::::NoPermissionToShare.into(), - )?; - - SharedPostIdsByOriginalPostId::::mutate(original_post_id, |ids| ids.push(new_post_id)); - Ok(()) - } - - pub(crate) fn move_post_to_space( - editor: T::AccountId, - post: &mut Post, - new_space_id: SpaceId, - ) -> DispatchResult { - let old_space_id_opt = post.try_get_space_id(); - let new_space = Spaces::::require_space(new_space_id)?; - - ensure!( - T::IsAccountBlocked::is_allowed_account(editor.clone(), new_space_id), - ModerationError::AccountIsBlocked - ); - Spaces::ensure_account_has_space_permission( - editor, - &new_space, - SpacePermission::CreatePosts, - Error::::NoPermissionToCreatePosts.into(), - )?; - ensure!( - T::IsPostBlocked::is_allowed_post(post.id, new_space_id), - ModerationError::PostIsBlocked - ); - ensure!( - T::IsContentBlocked::is_allowed_content(post.content.clone(), new_space_id), - ModerationError::ContentIsBlocked - ); - - match post.extension { - PostExtension::RegularPost | PostExtension::SharedPost(_) => { - if let Some(old_space_id) = old_space_id_opt { - PostIdsBySpaceId::::mutate(old_space_id, |post_ids| { - remove_from_vec(post_ids, post.id) - }); - } - - PostIdsBySpaceId::::mutate(new_space_id, |post_ids| post_ids.push(post.id)); - - post.space_id = Some(new_space_id); - PostById::::insert(post.id, post); - - Ok(()) - }, - _ => fail!(Error::::CannotUpdateSpaceIdOnComment), - } - } - - pub fn delete_post_from_space(post_id: PostId) -> DispatchResult { - let mut post = Self::require_post(post_id)?; - - if post.is_comment() { - post.extension = PostExtension::RegularPost; - } else { - let space_id = post.get_space_id()?; - - post.space_id = None; - PostIdsBySpaceId::::mutate(space_id, |post_ids| remove_from_vec(post_ids, post_id)); - } - - PostById::insert(post.id, post); - - Ok(()) - } -} diff --git a/pallets/posts/src/lib.rs b/pallets/posts/src/lib.rs deleted file mode 100644 index e4d611e..0000000 --- a/pallets/posts/src/lib.rs +++ /dev/null @@ -1,485 +0,0 @@ -//! # Posts Module -//! -//! Posts are the second crucial component of Subsocial after Spaces. This module allows you to -//! create, update, move (between spaces), and hide posts as well as manage owner(s). -//! -//! Posts can be compared to existing entities on web 2.0 platforms such as: -//! - Posts on Facebook, -//! - Tweets on Twitter, -//! - Images on Instagram, -//! - Articles on Medium, -//! - Shared links on Reddit, -//! - Questions and answers on Stack Overflow. - -#![cfg_attr(not(feature = "std"), no_std)] - -use codec::{Decode, Encode}; -use frame_support::{ - dispatch::{DispatchError, DispatchResult}, - ensure, fail, - traits::Get, -}; -use frame_system::ensure_signed; -use scale_info::TypeInfo; -#[cfg(feature = "std")] -use serde::{Deserialize, Serialize}; -use sp_runtime::RuntimeDebug; -use sp_std::prelude::*; - -use pallet_permissions::SpacePermission; -use pallet_spaces::{types::Space, Pallet as Spaces}; -use subsocial_support::{ - ensure_content_is_valid, new_who_and_when, remove_from_vec, - traits::{IsAccountBlocked, IsContentBlocked, IsPostBlocked}, - Content, ModerationError, PostId, SpaceId, WhoAndWhen, WhoAndWhenOf, -}; - -pub use pallet::*; -pub mod functions; - -pub mod types; -pub use types::*; - -#[cfg(feature = "runtime-benchmarks")] -mod benchmarking; -pub mod weights; - -// pub mod rpc; - -#[frame_support::pallet] -pub mod pallet { - use super::*; - - use crate::weights::WeightInfo; - use frame_support::{pallet_prelude::*, traits::IsType}; - use frame_system::pallet_prelude::*; - - #[pallet::config] - pub trait Config: - frame_system::Config - + pallet_space_follows::Config - + pallet_spaces::Config - + pallet_timestamp::Config - { - /// The overarching event type. - type RuntimeEvent: From> + IsType<::RuntimeEvent>; - - /// Max comments depth - #[pallet::constant] - type MaxCommentDepth: Get; - - type IsPostBlocked: IsPostBlocked; - - type WeightInfo: WeightInfo; - } - - #[pallet::pallet] - #[pallet::generate_store(pub(super) trait Store)] - #[pallet::without_storage_info] - pub struct Pallet(_); - - #[pallet::type_value] - pub fn DefaultForNextPostId() -> PostId { - FIRST_POST_ID - } - - /// The next post id. - #[pallet::storage] - #[pallet::getter(fn next_post_id)] - pub type NextPostId = StorageValue<_, PostId, ValueQuery, DefaultForNextPostId>; - - /// Get the details of a post by its' id. - #[pallet::storage] - #[pallet::getter(fn post_by_id)] - pub type PostById = StorageMap<_, Twox64Concat, PostId, Post>; - - /// Get the ids of all direct replies by their parent's post id. - #[pallet::storage] - #[pallet::getter(fn reply_ids_by_post_id)] - pub type ReplyIdsByPostId = - StorageMap<_, Twox64Concat, PostId, Vec, ValueQuery>; - - /// Get the ids of all posts in a given space, by the space's id. - #[pallet::storage] - #[pallet::getter(fn post_ids_by_space_id)] - pub type PostIdsBySpaceId = - StorageMap<_, Twox64Concat, SpaceId, Vec, ValueQuery>; - - /// Get the ids of all posts that have shared a given original post id. - #[pallet::storage] - #[pallet::getter(fn shared_post_ids_by_original_post_id)] - pub type SharedPostIdsByOriginalPostId = - StorageMap<_, Twox64Concat, PostId, Vec, ValueQuery>; - - #[pallet::event] - #[pallet::generate_deposit(pub(super) fn deposit_event)] - pub enum Event { - PostCreated { - account: T::AccountId, - post_id: PostId, - }, - PostUpdated { - account: T::AccountId, - post_id: PostId, - }, - PostMoved { - account: T::AccountId, - post_id: PostId, - from_space: Option, - to_space: Option, - }, - } - - #[pallet::error] - pub enum Error { - // Post related errors: - /// Post was not found by id. - PostNotFound, - /// An account is not a post owner. - NotAPostOwner, - /// Nothing to update in this post. - NoUpdatesForPost, - /// Root post should have a space id. - PostHasNoSpaceId, - /// Not allowed to create a post/comment when a scope (space or root post) is hidden. - CannotCreateInHiddenScope, - /// Post has no replies. - NoRepliesOnPost, - /// Cannot move a post to the same space. - CannotMoveToSameSpace, - - // Share related errors: - /// Cannot share, because the original post was not found. - OriginalPostNotFound, - /// Cannot share a post that is sharing another post. - CannotShareSharedPost, - /// This post's extension is not a `SharedPost`. - NotASharedPost, - - // Comment related errors: - /// Unknown parent comment id. - UnknownParentComment, - /// Post by `parent_id` is not of a `Comment` extension. - NotACommentByParentId, - /// Cannot update space id of a comment. - CannotUpdateSpaceIdOnComment, - /// Max comment depth reached. - MaxCommentDepthReached, - /// Only comment owner can update this comment. - NotACommentAuthor, - /// This post's extension is not a `Comment`. - NotComment, - - // Permissions related errors: - /// User has no permission to create root posts in this space. - NoPermissionToCreatePosts, - /// User has no permission to create comments (aka replies) in this space. - NoPermissionToCreateComments, - /// User has no permission to share posts/comments from this space to another space. - NoPermissionToShare, - /// User has no permission to update any posts in this space. - NoPermissionToUpdateAnyPost, - /// A post owner is not allowed to update their own posts in this space. - NoPermissionToUpdateOwnPosts, - /// A comment owner is not allowed to update their own comments in this space. - NoPermissionToUpdateOwnComments, - - /// `force_create_post` failed, because this post already exists. - /// Consider removing the post with `force_remove_post` first. - PostAlreadyExists, - } - - #[pallet::call] - impl Pallet { - #[pallet::call_index(0)] - #[pallet::weight( - match extension { - PostExtension::RegularPost => ::WeightInfo::create_post__regular(), - PostExtension::Comment(..) => ::WeightInfo::create_post__comment(), - PostExtension::SharedPost(..) => ::WeightInfo::create_post__shared(), - } - )] - pub fn create_post( - origin: OriginFor, - space_id_opt: Option, - extension: PostExtension, - content: Content, - ) -> DispatchResult { - let creator = ensure_signed(origin)?; - - ensure_content_is_valid(content.clone())?; - - let new_post_id = Self::next_post_id(); - let new_post: Post = - Post::new(new_post_id, creator.clone(), space_id_opt, extension, content.clone()); - - // Get space from either space_id_opt or Comment if a comment provided - let space = &new_post.get_space()?; - ensure!(!space.hidden, Error::::CannotCreateInHiddenScope); - - ensure!( - T::IsAccountBlocked::is_allowed_account(creator.clone(), space.id), - ModerationError::AccountIsBlocked - ); - ensure!( - T::IsContentBlocked::is_allowed_content(content, space.id), - ModerationError::ContentIsBlocked - ); - - let root_post = &mut new_post.get_root_post()?; - ensure!(!root_post.hidden, Error::::CannotCreateInHiddenScope); - - // Check whether account has permission to create Post (by extension) - let mut permission_to_check = SpacePermission::CreatePosts; - let mut error_on_permission_failed = Error::::NoPermissionToCreatePosts; - - if let PostExtension::Comment(_) = extension { - permission_to_check = SpacePermission::CreateComments; - error_on_permission_failed = Error::::NoPermissionToCreateComments; - } - - Spaces::ensure_account_has_space_permission( - creator.clone(), - space, - permission_to_check, - error_on_permission_failed.into(), - )?; - - match extension { - PostExtension::SharedPost(original_post_id) => - Self::create_shared_post(&creator, new_post_id, original_post_id)?, - PostExtension::Comment(comment_ext) => - Self::create_comment(new_post_id, comment_ext, root_post.id)?, - _ => (), - } - - if new_post.is_root_post() { - PostIdsBySpaceId::::mutate(space.id, |ids| ids.push(new_post_id)); - } - - PostById::insert(new_post_id, new_post); - NextPostId::::mutate(|n| { - *n += 1; - }); - - Self::deposit_event(Event::PostCreated { account: creator, post_id: new_post_id }); - Ok(()) - } - - #[pallet::call_index(1)] - #[pallet::weight(::WeightInfo::update_post())] - pub fn update_post( - origin: OriginFor, - post_id: PostId, - update: PostUpdate, - ) -> DispatchResult { - let editor = ensure_signed(origin)?; - - let has_updates = update.content.is_some() || update.hidden.is_some(); - - ensure!(has_updates, Error::::NoUpdatesForPost); - - let mut post = Self::require_post(post_id)?; - let space_opt = &post.try_get_space(); - - if let Some(space) = space_opt { - ensure!( - T::IsAccountBlocked::is_allowed_account(editor.clone(), space.id), - ModerationError::AccountIsBlocked - ); - Self::ensure_account_can_update_post(&editor, &post, space)?; - } - - let mut is_update_applied = false; - - if let Some(content) = update.content { - if content != post.content { - ensure_content_is_valid(content.clone())?; - - if let Some(space) = space_opt { - ensure!( - T::IsContentBlocked::is_allowed_content(content.clone(), space.id), - ModerationError::ContentIsBlocked - ); - } - - post.content = content; - post.edited = true; - is_update_applied = true; - } - } - - if let Some(hidden) = update.hidden { - if hidden != post.hidden { - post.hidden = hidden; - is_update_applied = true; - } - } - - // Update this post only if at least one field should be updated: - if is_update_applied { - >::insert(post.id, post); - Self::deposit_event(Event::PostUpdated { account: editor, post_id }); - } - Ok(()) - } - - #[pallet::call_index(2)] - #[pallet::weight(::WeightInfo::move_post())] - pub fn move_post( - origin: OriginFor, - post_id: PostId, - new_space_id: Option, - ) -> DispatchResult { - let who = ensure_signed(origin)?; - - let post = &mut Self::require_post(post_id)?; - - ensure!(new_space_id != post.space_id, Error::::CannotMoveToSameSpace); - - if let Some(space) = post.try_get_space() { - Self::ensure_account_can_update_post(&who, post, &space)?; - } else { - post.ensure_owner(&who)?; - } - - let old_space_id = post.space_id; - - if let Some(space_id) = new_space_id { - Self::move_post_to_space(who.clone(), post, space_id)?; - } else { - Self::delete_post_from_space(post_id)?; - } - - Self::deposit_event(Event::PostMoved { - account: who, - post_id, - from_space: old_space_id, - to_space: new_space_id, - }); - Ok(()) - } - - #[pallet::call_index(3)] - #[pallet::weight(( - Weight::from_ref_time(50_000) + T::DbWeight::get().reads_writes(4, 3), - DispatchClass::Operational, - Pays::Yes, - ))] - pub fn force_create_post( - origin: OriginFor, - post_id: PostId, - created: WhoAndWhenOf, - owner: T::AccountId, - extension: PostExtension, - space_id_opt: Option, - content: Content, - hidden: bool, - upvotes_count: u32, - downvotes_count: u32, - ) -> DispatchResultWithPostInfo { - ensure_root(origin)?; - - ensure!(Self::require_post(post_id).is_err(), Error::::PostAlreadyExists); - - let WhoAndWhen { account, time, .. } = created; - let new_who_and_when = - WhoAndWhen { account, block: frame_system::Pallet::::block_number(), time }; - - let new_post = Post:: { - id: post_id, - created: new_who_and_when, - edited: false, - owner: owner.clone(), - extension, - space_id: space_id_opt, - content, - hidden, - upvotes_count, - downvotes_count, - }; - - if new_post.is_root_post() { - if let Some(space_id) = new_post.space_id { - PostIdsBySpaceId::::mutate(space_id, |ids| ids.push(post_id)); - } - } - - match new_post.extension { - PostExtension::Comment(ext) => { - let commented_post_id = ext.parent_id.unwrap_or(ext.root_post_id); - ReplyIdsByPostId::::mutate(commented_post_id, |reply_ids| { - reply_ids.push(post_id) - }); - }, - PostExtension::SharedPost(original_post_id) => { - SharedPostIdsByOriginalPostId::::mutate(original_post_id, |ids| { - ids.push(post_id) - }); - }, - _ => (), - } - - PostById::insert(post_id, new_post); - - Self::deposit_event(Event::PostCreated { account: owner, post_id }); - Ok(Pays::No.into()) - } - - #[pallet::call_index(4)] - #[pallet::weight(( - Weight::from_ref_time(10_000) + T::DbWeight::get().reads_writes(2, 3), - DispatchClass::Operational, - Pays::Yes, - ))] - pub fn force_remove_post( - origin: OriginFor, - post_id: PostId, - ) -> DispatchResultWithPostInfo { - ensure_root(origin)?; - - if let Ok(old_post) = Self::require_post(post_id) { - if old_post.is_root_post() { - if let Some(space_id) = old_post.space_id { - PostIdsBySpaceId::::mutate(space_id, |ids| { - remove_from_vec(ids, post_id) - }); - } - } - - match old_post.extension { - PostExtension::Comment(ext) => { - let commented_post_id = ext.parent_id.unwrap_or(ext.root_post_id); - ReplyIdsByPostId::::mutate(commented_post_id, |reply_ids| { - remove_from_vec(reply_ids, post_id) - }); - }, - PostExtension::SharedPost(original_post_id) => { - SharedPostIdsByOriginalPostId::::mutate(original_post_id, |ids| { - remove_from_vec(ids, post_id) - }); - }, - _ => (), - } - PostById::::remove(post_id); - } - - Ok(Pays::No.into()) - } - - #[pallet::call_index(5)] - #[pallet::weight(( - Weight::from_ref_time(10_000) + T::DbWeight::get().writes(1), - DispatchClass::Operational, - Pays::Yes, - ))] - pub fn force_set_next_post_id( - origin: OriginFor, - post_id: PostId, - ) -> DispatchResultWithPostInfo { - ensure_root(origin)?; - NextPostId::::put(post_id); - Ok(Pays::No.into()) - } - } -} diff --git a/pallets/posts/src/rpc.rs b/pallets/posts/src/rpc.rs deleted file mode 100644 index 9d3fb9e..0000000 --- a/pallets/posts/src/rpc.rs +++ /dev/null @@ -1,313 +0,0 @@ -use codec::{Decode, Encode}; -#[cfg(feature = "std")] -use serde::{Deserialize, Serialize}; -use sp_std::collections::{btree_map::BTreeMap, btree_set::BTreeSet}; -use sp_std::{vec, prelude::*}; - -use pallet_space_follows::Module as SpaceFollows; -use pallet_spaces::Module as Spaces; -use pallet_utils::{bool_to_option, PostId, rpc::{FlatContent, FlatWhoAndWhen, ShouldSkip}, SpaceId}; - -use crate::{Module, Post, PostExtension, FIRST_POST_ID, Config}; -pub type RepliesByPostId = BTreeMap>>; - -#[derive(Eq, PartialEq, Encode, Decode, Default)] -#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))] -#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))] -pub struct FlatPostExtension { - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] - pub is_regular_post: Option, - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] - pub is_shared_post: Option, - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] - pub is_comment: Option, - - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] - pub root_post_id: Option, - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] - pub parent_post_id: Option, - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] - pub shared_post_id: Option, -} - -impl From for FlatPostExtension { - fn from(from: PostExtension) -> Self { - let mut flat_ext = Self::default(); - - match from { - PostExtension::RegularPost => { - flat_ext.is_regular_post = Some(true); - } - PostExtension::Comment(comment_ext) => { - flat_ext.is_comment = Some(true); - flat_ext.root_post_id = Some(comment_ext.root_post_id); - flat_ext.parent_post_id = comment_ext.parent_id; - } - PostExtension::SharedPost(shared_post_id) => { - flat_ext.is_shared_post = Some(true); - flat_ext.shared_post_id = Some(shared_post_id); - } - } - - flat_ext - } -} - -#[derive(Eq, PartialEq, Encode, Decode, Default)] -#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))] -#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))] -pub struct FlatPost { - pub id: PostId, - - #[cfg_attr(feature = "std", serde(flatten))] - pub who_and_when: FlatWhoAndWhen, - - pub owner: AccountId, - - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] - pub space_id: Option, - - #[cfg_attr(feature = "std", serde(flatten))] - pub content: FlatContent, - - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] - pub is_hidden: Option, - - #[cfg_attr(feature = "std", serde(flatten))] - pub extension: FlatPostExtension, - - pub replies_count: u16, - pub hidden_replies_count: u16, - pub visible_replies_count: u16, - - pub shares_count: u16, - pub upvotes_count: u16, - pub downvotes_count: u16, -} - -#[derive(Encode, Decode, Ord, PartialOrd, Clone, Eq, PartialEq)] -#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] -pub enum FlatPostKind { - RegularPost, - Comment, - SharedPost -} - -impl From> for FlatPostKind { - fn from(from: Post) -> Self { - match from.extension { - PostExtension::RegularPost => { Self::RegularPost } - PostExtension::Comment(_) => { Self::Comment } - PostExtension::SharedPost(_) => { Self::SharedPost } - } - } -} - -impl From> for FlatPost { - fn from(from: Post) -> Self { - let Post { - id, created, updated, owner, - extension, space_id, content, hidden, replies_count, - hidden_replies_count, shares_count, upvotes_count, downvotes_count, .. - } = from; - - Self { - id, - who_and_when: (created, updated).into(), - owner, - space_id, - content: content.into(), - is_hidden: bool_to_option(hidden), - extension: extension.into(), - replies_count, - hidden_replies_count, - visible_replies_count: replies_count.saturating_sub(hidden_replies_count), - shares_count, - upvotes_count, - downvotes_count, - } - } -} - -impl Module { - fn get_posts_by_ids_with_filter) -> bool>( - all_post_ids: Vec, - offset: u64, - limit: u16, - mut filter: F, - ) -> Vec> { - let mut posts = Vec::new(); - - let (_, posts_ids) = all_post_ids.split_at(offset as usize); - - for post_id in posts_ids.iter() { - if let Ok(post) = Self::require_post(*post_id) { - if filter(&post) { - posts.push(post.into()); - } - } - - if posts.len() >= limit as usize { break; } - } - - posts - } - - pub fn get_posts_by_ids ( - post_ids: Vec, - offset: u64, - limit: u16, - ) -> Vec> { - Self::get_posts_by_ids_with_filter(post_ids, offset, limit, |_| true) - } - - pub fn get_public_posts_by_ids( - post_ids: Vec, - offset: u64, - limit: u16, - ) -> Vec> { - Self::get_posts_by_ids_with_filter(post_ids, offset, limit, |post| post.is_public()) - } - - fn get_posts_slice_by_space_id) -> bool>( - space_id: SpaceId, - offset: u64, - limit: u16, - filter: F, - ) -> Vec> { - let mut post_ids: Vec = Self::post_ids_by_space_id(space_id); - post_ids.reverse(); - - Self::get_posts_by_ids_with_filter(post_ids, offset, limit, filter) - } - - pub fn get_public_posts_by_space_id( - space_id: SpaceId, - offset: u64, - limit: u16, - ) -> Vec> { - if let Ok(space) = Spaces::::require_space(space_id) { - return Self::get_posts_slice_by_space_id(space.id, offset, limit, |post| post.is_public()); - } - - vec![] - } - - pub fn get_unlisted_posts_by_space_id( - space_id: SpaceId, - offset: u64, - limit: u16, - ) -> Vec> { - if let Ok(space) = Spaces::::require_space(space_id) { - return Self::get_posts_slice_by_space_id(space.id, offset, limit, |post| post.is_unlisted()); - } - - vec![] - } - - pub fn get_reply_ids_by_parent_id(parent_id: PostId) -> Vec { - Self::reply_ids_by_post_id(parent_id) - } - - pub fn get_replies_by_parent_id(parent_id: PostId, offset: u64, limit: u16) -> Vec> { - let reply_ids = Self::get_reply_ids_by_parent_id(parent_id); - Self::get_posts_by_ids(reply_ids, offset, limit) - } - - pub fn get_reply_ids_by_parent_ids(parent_ids: Vec) -> BTreeMap> { - let mut reply_ids_by_parent: BTreeMap> = BTreeMap::new(); - - for parent_id in parent_ids.iter() { - let reply_ids = Self::get_reply_ids_by_parent_id(*parent_id); - - if !reply_ids.is_empty() { - reply_ids_by_parent.insert(*parent_id, reply_ids); - } - } - - reply_ids_by_parent - } - - pub fn get_replies_by_parent_ids( - parent_ids: Vec, - offset: u64, - limit: u16 - ) -> RepliesByPostId { - - Self::get_reply_ids_by_parent_ids(parent_ids) - .into_iter() - .map(|(parent_id, reply_ids)| - (parent_id, Self::get_posts_by_ids(reply_ids, offset, limit)) - ) - .collect() - } - - pub fn get_public_posts( - kind_filter: Vec, - start_id: u64, - limit: u16, - ) -> Vec> { - - let no_filter = kind_filter.is_empty(); - let kind_filter_set: BTreeSet<_> = kind_filter.into_iter().collect(); - - let mut posts = Vec::new(); - let mut post_id = start_id; - - while posts.len() < limit as usize && post_id >= FIRST_POST_ID { - if let Ok(post) = Self::require_post(post_id) { - let kind: FlatPostKind = post.clone().into(); - - if post.is_public() && (no_filter || kind_filter_set.contains(&kind)) { - posts.push(post.into()); - } - } - post_id = post_id.saturating_sub(1); - } - - posts - } - - fn get_post_ids_by_space) -> bool>(space_id: SpaceId, mut filter: F) -> Vec { - Self::post_ids_by_space_id(space_id) - .iter() - .filter_map(Self::post_by_id) - .filter(|post| filter(post)) - .map(|post| post.id) - .collect() - } - - pub fn get_public_post_ids_by_space_id(space_id: SpaceId) -> Vec { - let public_space = Spaces::::require_space(space_id).ok().filter(|space| space.is_public()); - if public_space.is_some() { - return Self::get_post_ids_by_space(space_id, |post| post.is_public()); - } - - vec![] - } - - pub fn get_unlisted_post_ids_by_space_id(space_id: SpaceId) -> Vec { - let unlisted_space = Spaces::::require_space(space_id).ok().filter(|space| !space.is_public()); - if unlisted_space.is_some() { - return Self::get_post_ids_by_space(space_id, |post| !post.is_public()); - } - - vec![] - } - - pub fn get_next_post_id() -> PostId { - Self::next_post_id() - } - - pub fn get_feed(account: T::AccountId, offset: u64, limit: u16) -> Vec> { - let mut post_ids: Vec = SpaceFollows::::spaces_followed_by_account(account) - .iter() - .flat_map(Self::post_ids_by_space_id) - .collect(); - - // Sort post ids in a descending order - post_ids.sort_by(|a, b| b.cmp(a)); - - Self::get_posts_by_ids_with_filter(post_ids, offset, limit, |post| post.is_public() && !post.is_comment()) - } -} diff --git a/pallets/posts/src/types.rs b/pallets/posts/src/types.rs deleted file mode 100644 index ff0ab21..0000000 --- a/pallets/posts/src/types.rs +++ /dev/null @@ -1,71 +0,0 @@ -use super::*; - -pub const FIRST_POST_ID: u64 = 1; - -/// Information about a post's owner, its' related space, content, and visibility. -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -#[scale_info(skip_type_params(T))] -pub struct Post { - /// Unique sequential identifier of a post. Examples of post ids: `1`, `2`, `3`, and so on. - pub id: PostId, - - pub created: WhoAndWhenOf, - /// True, if the content of this post was edited. - pub edited: bool, - - /// The current owner of a given post. - pub owner: T::AccountId, - - /// Through post extension you can provide specific information necessary for different kinds - /// of posts such as regular posts, comments, and shared posts. - pub extension: PostExtension, - - /// An id of a space which contains a given post. - pub space_id: Option, - - pub content: Content, - - /// Hidden field is used to recommend to end clients (web and mobile apps) that a particular - /// posts and its' comments should not be shown. - pub hidden: bool, - - /// The number of times a given post has been upvoted. - pub upvotes_count: u32, - - /// The number of times a given post has been downvoted. - pub downvotes_count: u32, -} - -#[derive(Encode, Decode, Default, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -pub struct PostUpdate { - /// Deprecated: This field has no effect in `fn update_post()` extrinsic. - /// See `fn move_post()` extrinsic if you want to move a post to another space. - pub space_id: Option, - - pub content: Option, - pub hidden: Option, -} - -/// Post extension provides specific information necessary for different kinds -/// of posts such as regular posts, comments, and shared posts. -#[derive(Encode, Decode, Clone, Copy, Eq, PartialEq, RuntimeDebug, TypeInfo)] -#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] -#[cfg_attr(feature = "std", serde(untagged))] -pub enum PostExtension { - RegularPost, - Comment(Comment), - SharedPost(PostId), -} - -#[derive(Encode, Decode, Clone, Copy, Eq, PartialEq, RuntimeDebug, TypeInfo)] -#[cfg_attr(feature = "std", derive(Serialize, Deserialize))] -pub struct Comment { - pub root_post_id: PostId, - pub parent_id: Option, -} - -impl Default for PostExtension { - fn default() -> Self { - PostExtension::RegularPost - } -} diff --git a/pallets/posts/src/weights.rs b/pallets/posts/src/weights.rs deleted file mode 100644 index e756f9a..0000000 --- a/pallets/posts/src/weights.rs +++ /dev/null @@ -1,169 +0,0 @@ - -//! Autogenerated weights for pallet_posts -//! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-02-14, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 - -// Executed Command: - // ./scripts/../target/release/subsocial-collator - // benchmark - // pallet - // --chain - // dev - // --execution - // wasm - // --wasm-execution - // Compiled - // --pallet - // pallet_posts - // --extrinsic - // * - // --steps - // 50 - // --repeat - // 20 - // --heap-pages - // 4096 - // --output - // pallets/posts/src/weights.rs - // --template - // ./.maintain/weight-template.hbs - -#![cfg_attr(rustfmt, rustfmt_skip)] -#![allow(unused_parens)] -#![allow(unused_imports)] -#![allow(non_snake_case)] - -use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; -use sp_std::marker::PhantomData; - -/// Weight functions needed for pallet_posts. -pub trait WeightInfo { - fn create_post__regular() -> Weight; - fn create_post__shared() -> Weight; - fn create_post__comment() -> Weight; - fn update_post() -> Weight; - fn move_post() -> Weight; -} - -/// Weights for pallet_posts using the Substrate node and recommended hardware. -pub struct SubstrateWeight(PhantomData); - impl WeightInfo for SubstrateWeight { - // Storage: Posts NextPostId (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) - // Storage: Posts PostIdsBySpaceId (r:1 w:1) - // Storage: Posts PostById (r:0 w:1) - fn create_post__regular() -> Weight { - // Minimum execution time: 30_000 nanoseconds. - Weight::from_ref_time(47_502_000) - .saturating_add(T::DbWeight::get().reads(5)) - .saturating_add(T::DbWeight::get().writes(3)) - } - // Storage: Posts NextPostId (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) - // Storage: Posts PostById (r:1 w:1) - // Storage: Posts SharedPostIdsByOriginalPostId (r:1 w:1) - // Storage: Posts PostIdsBySpaceId (r:1 w:1) - fn create_post__shared() -> Weight { - // Minimum execution time: 39_000 nanoseconds. - Weight::from_ref_time(62_353_000) - .saturating_add(T::DbWeight::get().reads(7)) - .saturating_add(T::DbWeight::get().writes(4)) - } - // Storage: Posts NextPostId (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) - // Storage: Posts PostById (r:2 w:1) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) - // Storage: Posts ReplyIdsByPostId (r:1 w:1) - fn create_post__comment() -> Weight { - // Minimum execution time: 39_000 nanoseconds. - Weight::from_ref_time(59_771_000) - .saturating_add(T::DbWeight::get().reads(7)) - .saturating_add(T::DbWeight::get().writes(3)) - } - // Storage: Posts PostById (r:2 w:1) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) - fn update_post() -> Weight { - // Minimum execution time: 30_000 nanoseconds. - Weight::from_ref_time(48_472_000) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(1)) - } - // Storage: Posts PostById (r:1 w:1) - // Storage: Spaces SpaceById (r:2 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:2 w:0) - // Storage: Posts PostIdsBySpaceId (r:2 w:2) - fn move_post() -> Weight { - // Minimum execution time: 39_000 nanoseconds. - Weight::from_ref_time(60_733_000) - .saturating_add(T::DbWeight::get().reads(7)) - .saturating_add(T::DbWeight::get().writes(3)) - } - } - - // For backwards compatibility and tests - impl WeightInfo for () { - // Storage: Posts NextPostId (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) - // Storage: Posts PostIdsBySpaceId (r:1 w:1) - // Storage: Posts PostById (r:0 w:1) - fn create_post__regular() -> Weight { - // Minimum execution time: 30_000 nanoseconds. - Weight::from_ref_time(47_502_000) - .saturating_add(RocksDbWeight::get().reads(5)) - .saturating_add(RocksDbWeight::get().writes(3)) - } - // Storage: Posts NextPostId (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) - // Storage: Posts PostById (r:1 w:1) - // Storage: Posts SharedPostIdsByOriginalPostId (r:1 w:1) - // Storage: Posts PostIdsBySpaceId (r:1 w:1) - fn create_post__shared() -> Weight { - // Minimum execution time: 39_000 nanoseconds. - Weight::from_ref_time(62_353_000) - .saturating_add(RocksDbWeight::get().reads(7)) - .saturating_add(RocksDbWeight::get().writes(4)) - } - // Storage: Posts NextPostId (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) - // Storage: Posts PostById (r:2 w:1) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) - // Storage: Posts ReplyIdsByPostId (r:1 w:1) - fn create_post__comment() -> Weight { - // Minimum execution time: 39_000 nanoseconds. - Weight::from_ref_time(59_771_000) - .saturating_add(RocksDbWeight::get().reads(7)) - .saturating_add(RocksDbWeight::get().writes(3)) - } - // Storage: Posts PostById (r:2 w:1) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) - fn update_post() -> Weight { - // Minimum execution time: 30_000 nanoseconds. - Weight::from_ref_time(48_472_000) - .saturating_add(RocksDbWeight::get().reads(4)) - .saturating_add(RocksDbWeight::get().writes(1)) - } - // Storage: Posts PostById (r:1 w:1) - // Storage: Spaces SpaceById (r:2 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:2 w:0) - // Storage: Posts PostIdsBySpaceId (r:2 w:2) - fn move_post() -> Weight { - // Minimum execution time: 39_000 nanoseconds. - Weight::from_ref_time(60_733_000) - .saturating_add(RocksDbWeight::get().reads(7)) - .saturating_add(RocksDbWeight::get().writes(3)) - } - } diff --git a/pallets/posts/tests/Cargo.toml b/pallets/posts/tests/Cargo.toml deleted file mode 100644 index 8c20489..0000000 --- a/pallets/posts/tests/Cargo.toml +++ /dev/null @@ -1,60 +0,0 @@ -[package] -name = 'pallet-posts-tests' -version = '0.1.7' -authors = ['DappForce '] -edition = '2021' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Posts pallet tests' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[package.metadata.docs.rs] -targets = ["x86_64-unknown-linux-gnu"] - -[dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } - -# Local dependencies -subsocial-support = { default-features = false, path = '../../support' } -pallet-permissions = { default-features = false, path = '../../permissions' } - -# Substrate dependencies -pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } - -[dev-dependencies] -sp-core = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-io = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } -pallet-roles = { default-features = false, path = '../../roles' } -pallet-space-follows = { default-features = false, path = '../../space-follows' } -pallet-space-ownership = { default-features = false, path = '../../space-ownership' } -pallet-profiles = { default-features = false, path = '../../profiles' } -pallet-posts = { default-features = false, path = '..' } -pallet-spaces = { default-features = false, path = '../../spaces' } - -[features] -default = ['std'] -std = [ - 'codec/std', - 'scale-info/std', - 'pallet-timestamp/std', - 'frame-support/std', - 'frame-system/std', - 'sp-runtime/std', - 'sp-std/std', - 'pallet-permissions/std', - 'pallet-balances/std', - 'pallet-roles/std', - 'pallet-space-follows/std', - 'pallet-space-ownership/std', - 'pallet-profiles/std', - 'pallet-posts/std', -] -try-runtime = ["frame-support/try-runtime"] diff --git a/pallets/posts/tests/src/comments_tests.rs b/pallets/posts/tests/src/comments_tests.rs deleted file mode 100644 index 265d8a1..0000000 --- a/pallets/posts/tests/src/comments_tests.rs +++ /dev/null @@ -1,209 +0,0 @@ -use frame_support::{assert_noop, assert_ok}; -use sp_runtime::DispatchError; - -use pallet_posts::Error as PostsError; -use subsocial_support::{mock_functions::*, ContentError, PostId}; - -use crate::{mock::*, tests_utils::*}; - -#[test] -fn create_comment_should_work() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_create_default_comment()); // PostId 2 by ACCOUNT1 which is permitted by default - - // Check storages - assert_eq!(Posts::reply_ids_by_post_id(POST1), vec![POST2]); - - // Check whether data stored correctly - let comment = Posts::post_by_id(POST2).unwrap(); - let comment_ext = comment.get_comment_ext().unwrap(); - - assert!(comment_ext.parent_id.is_none()); - assert_eq!(comment_ext.root_post_id, POST1); - assert_eq!(comment.created.account, ACCOUNT1); - assert!(!comment.edited); - assert_eq!(comment.content, comment_content_ipfs()); - - assert_eq!(comment.upvotes_count, 0); - assert_eq!(comment.downvotes_count, 0); - }); -} - -#[test] -fn create_comment_should_work_when_comment_has_parents() { - ExtBuilder::build_with_comment().execute_with(|| { - let first_comment_id = 2; - let last_comment_id = first_comment_id + (MaxCommentDepth::get() as PostId) - 1; - - // Create - for parent_id in first_comment_id..last_comment_id { - assert_ok!(_create_comment(None, None, Some(Some(parent_id)), None)); - } - - let parent_id = last_comment_id - 1; - let parent_id_by_one = parent_id - 1; - - // We should check that counters were increased by 1 for all ancestor comments - // except the last parent. - for comment_id in first_comment_id..parent_id_by_one { - // All of comments has 1 reply as they respond to each other. - assert_eq!(Posts::reply_ids_by_post_id(comment_id), vec![comment_id + 1]); - } - - assert_eq!(Posts::reply_ids_by_post_id(parent_id), vec![last_comment_id]); - - assert!(Posts::reply_ids_by_post_id(last_comment_id).is_empty()); - }); -} - -#[test] -fn create_comment_should_fail_when_post_not_found() { - ExtBuilder::build().execute_with(|| { - // Try to catch an error creating a comment with wrong post - assert_noop!(_create_default_comment(), PostsError::::PostNotFound); - }); -} - -#[test] -fn create_comment_should_fail_when_parent_comment_is_unknown() { - ExtBuilder::build_with_post().execute_with(|| { - // Try to catch an error creating a comment with wrong parent - assert_noop!( - _create_comment(None, None, Some(Some(POST2)), None), - PostsError::::UnknownParentComment - ); - }); -} - -#[test] -fn create_comment_should_fail_when_ipfs_cid_is_invalid() { - ExtBuilder::build_with_post().execute_with(|| { - // Try to catch an error creating a comment with wrong parent - assert_noop!( - _create_comment(None, None, None, Some(invalid_content_ipfs())), - DispatchError::from(ContentError::InvalidIpfsCid) - ); - }); -} - -#[test] -fn create_comment_should_fail_when_trying_to_create_in_hidden_space_scope() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_update_space(None, None, Some(space_update(None, Some(true))))); - - assert_noop!(_create_default_comment(), PostsError::::CannotCreateInHiddenScope); - }); -} - -#[test] -fn create_comment_should_fail_when_trying_create_in_hidden_post_scope() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_update_post(None, None, Some(post_update(None, None, Some(true))))); - - assert_noop!(_create_default_comment(), PostsError::::CannotCreateInHiddenScope); - }); -} - -#[test] -fn create_comment_should_fail_when_max_comment_depth_reached() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_create_comment(None, None, Some(None), None)); // PostId 2 - - for parent_id in 2..11_u64 { - assert_ok!(_create_comment(None, None, Some(Some(parent_id)), None)); - // PostId N (last = 10) - } - - // Some(Some(11)) - here is parent_id 11 of type PostId - assert_noop!( - _create_comment(None, None, Some(Some(11)), None), - PostsError::::MaxCommentDepthReached - ); - }); -} - -#[test] -fn update_comment_should_work() { - ExtBuilder::build_with_comment().execute_with(|| { - // Post update with ID 1 should be fine - assert_ok!(_update_comment(None, None, None)); - - // Check whether post updates correctly - let comment = Posts::post_by_id(POST2).unwrap(); - assert_eq!(comment.content, reply_content_ipfs()); - }); -} - -#[test] -fn update_comment_hidden_should_work_when_comment_has_parents() { - ExtBuilder::build_with_comment().execute_with(|| { - let first_comment_id = 2; - let last_comment_id = first_comment_id + (MaxCommentDepth::get() as PostId) - 1; - - // Create comments from 3 to 11 - for parent_id in first_comment_id..last_comment_id { - assert_ok!(_create_comment(None, None, Some(Some(parent_id)), None)); - } - - let should_hide_id = last_comment_id - 3; - let should_hide_by_one_id = should_hide_id - 1; - - assert_ok!(_update_comment( - None, - Some(should_hide_id), - Some(post_update( - None, - None, - Some(true) // make comment hidden - )) - )); - - // We should check that counters weren't increased for all ancestor comments - // except the last before hidden. - for comment_id in first_comment_id..should_hide_by_one_id { - // All of comments has 1 replies as they reply to each other. - assert_eq!(Posts::reply_ids_by_post_id(comment_id), vec![comment_id + 1]); - } - - assert_eq!( - Posts::reply_ids_by_post_id(should_hide_by_one_id), - vec![should_hide_by_one_id + 1] - ); - assert_eq!(Posts::reply_ids_by_post_id(should_hide_id), vec![should_hide_id + 1]); - }); -} - -#[test] -// `PostNotFound` here: Post with Comment extension. Means that comment wasn't found. -fn update_comment_should_fail_when_post_not_found() { - ExtBuilder::build().execute_with(|| { - // Try to catch an error updating a comment with wrong PostId - assert_noop!(_update_comment(None, None, None), PostsError::::PostNotFound); - }); -} - -#[test] -fn update_comment_should_fail_when_account_is_not_a_comment_author() { - ExtBuilder::build_with_comment().execute_with(|| { - // Try to catch an error updating a comment with wrong Account - assert_noop!( - _update_comment(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None), - PostsError::::NotACommentAuthor - ); - }); -} - -#[test] -fn update_comment_should_fail_when_ipfs_cid_is_invalid() { - ExtBuilder::build_with_comment().execute_with(|| { - // Try to catch an error updating a comment with invalid content - assert_noop!( - _update_comment( - None, - None, - Some(post_update(None, Some(invalid_content_ipfs()), None)) - ), - DispatchError::from(ContentError::InvalidIpfsCid) - ); - }); -} diff --git a/pallets/posts/tests/src/lib.rs b/pallets/posts/tests/src/lib.rs deleted file mode 100644 index d2fbb87..0000000 --- a/pallets/posts/tests/src/lib.rs +++ /dev/null @@ -1,10 +0,0 @@ -#[cfg(test)] -mod comments_tests; -#[cfg(test)] -mod mock; -#[cfg(test)] -mod post_tests; -#[cfg(test)] -mod shared_posts_tests; -#[cfg(test)] -mod tests_utils; diff --git a/pallets/posts/tests/src/mock.rs b/pallets/posts/tests/src/mock.rs deleted file mode 100644 index da6192a..0000000 --- a/pallets/posts/tests/src/mock.rs +++ /dev/null @@ -1,151 +0,0 @@ -use frame_support::{pallet_prelude::ConstU32, parameter_types, traits::Everything}; -use sp_core::H256; -use sp_runtime::{ - testing::Header, - traits::{BlakeTwo256, IdentityLookup}, -}; -use sp_std::convert::{TryFrom, TryInto}; - -use crate::tests_utils::*; - -type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; -type Block = frame_system::mocking::MockBlock; - -frame_support::construct_runtime!( - pub enum Test where - Block = Block, - NodeBlock = Block, - UncheckedExtrinsic = UncheckedExtrinsic, - { - System: frame_system, - Timestamp: pallet_timestamp, - Balances: pallet_balances, - Permissions: pallet_permissions, - Roles: pallet_roles, - Profiles: pallet_profiles, - SpaceFollows: pallet_space_follows, - Posts: pallet_posts, - Spaces: pallet_spaces, - SpaceOwnership: pallet_space_ownership, - } -); - -pub(super) type AccountId = u64; -pub(super) type Balance = u64; -pub(super) type BlockNumber = u64; - -parameter_types! { - pub const BlockHashCount: u64 = 250; - pub const SS58Prefix: u8 = 42; -} - -impl frame_system::Config for Test { - type BaseCallFilter = Everything; - type BlockWeights = (); - type BlockLength = (); - type RuntimeOrigin = RuntimeOrigin; - type RuntimeCall = RuntimeCall; - type Index = u64; - type BlockNumber = BlockNumber; - type Hash = H256; - type Hashing = BlakeTwo256; - type AccountId = AccountId; - type Lookup = IdentityLookup; - type Header = Header; - type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; - type DbWeight = (); - type Version = (); - type PalletInfo = PalletInfo; - type AccountData = pallet_balances::AccountData; - type OnNewAccount = (); - type OnKilledAccount = (); - type SystemWeightInfo = (); - type SS58Prefix = SS58Prefix; - type OnSetCode = (); - type MaxConsumers = frame_support::traits::ConstU32<16>; -} - -parameter_types! { - pub const MinimumPeriod: u64 = 5; -} - -impl pallet_timestamp::Config for Test { - type Moment = u64; - type OnTimestampSet = (); - type MinimumPeriod = MinimumPeriod; - type WeightInfo = (); -} - -parameter_types! { - pub const ExistentialDeposit: u64 = 1; -} - -impl pallet_balances::Config for Test { - type Balance = Balance; - type DustRemoval = (); - type RuntimeEvent = RuntimeEvent; - type ExistentialDeposit = ExistentialDeposit; - type AccountStore = System; - type WeightInfo = (); - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = (); -} - -parameter_types! { - pub const MaxCommentDepth: u32 = 10; -} - -impl pallet_posts::Config for Test { - type RuntimeEvent = RuntimeEvent; - type MaxCommentDepth = MaxCommentDepth; - type IsPostBlocked = MockModeration; - type WeightInfo = (); -} - -impl pallet_permissions::Config for Test { - type DefaultSpacePermissions = pallet_permissions::default_permissions::DefaultSpacePermissions; -} - -parameter_types! { - pub const MaxUsersToProcessPerDeleteRole: u16 = 40; -} - -impl pallet_roles::Config for Test { - type RuntimeEvent = RuntimeEvent; - type MaxUsersToProcessPerDeleteRole = MaxUsersToProcessPerDeleteRole; - type SpacePermissionsProvider = Spaces; - type SpaceFollows = SpaceFollows; - type IsAccountBlocked = MockModeration; - type IsContentBlocked = MockModeration; - type WeightInfo = (); -} - -impl pallet_profiles::Config for Test { - type RuntimeEvent = RuntimeEvent; - type SpacePermissionsProvider = Spaces; - type SpacesInterface = Spaces; - type WeightInfo = (); -} - -impl pallet_spaces::Config for Test { - type RuntimeEvent = RuntimeEvent; - type Roles = Roles; - type SpaceFollows = SpaceFollows; - type IsAccountBlocked = MockModeration; - type IsContentBlocked = MockModeration; - type MaxSpacesPerAccount = ConstU32<100>; - type WeightInfo = (); -} - -impl pallet_space_follows::Config for Test { - type RuntimeEvent = RuntimeEvent; - type WeightInfo = (); -} - -impl pallet_space_ownership::Config for Test { - type RuntimeEvent = RuntimeEvent; - type ProfileManager = Profiles; - type WeightInfo = (); -} diff --git a/pallets/posts/tests/src/post_tests.rs b/pallets/posts/tests/src/post_tests.rs deleted file mode 100644 index 973c98b..0000000 --- a/pallets/posts/tests/src/post_tests.rs +++ /dev/null @@ -1,612 +0,0 @@ -use frame_support::{assert_noop, assert_ok}; -use sp_runtime::DispatchError; - -use pallet_permissions::SpacePermission as SP; -use pallet_posts::{Error as PostsError, Post}; -use pallet_spaces::Error as SpacesError; -use subsocial_support::{mock_functions::*, ContentError, ModerationError, PostId, SpaceId}; - -use crate::{mock::*, tests_utils::*}; - -#[test] -fn create_post_should_fail_when_content_is_blocked() { - ExtBuilder::build_with_post().execute_with(|| { - block_content_in_space_1(); - assert_noop!( - _create_post(None, None, None, Some(valid_content_ipfs()),), - DispatchError::Other(ModerationError::ContentIsBlocked.into()), - ); - }); -} - -#[test] -fn create_post_should_fail_when_account_is_blocked() { - ExtBuilder::build_with_post().execute_with(|| { - block_account_in_space_1(); - assert_noop!( - _create_post(None, None, None, Some(valid_content_ipfs()),), - DispatchError::Other(ModerationError::AccountIsBlocked.into()), - ); - }); -} - -#[test] -fn update_post_should_fail_when_content_is_blocked() { - ExtBuilder::build_with_post().execute_with(|| { - block_content_in_space_1(); - assert_noop!( - _update_post( - None, // From ACCOUNT1 (has default permission to UpdateOwnPosts) - None, - Some(post_update(None, Some(valid_content_ipfs()), Some(true))) - ), - DispatchError::Other(ModerationError::ContentIsBlocked.into()) - ); - }); -} - -#[test] -fn update_post_should_fail_when_account_is_blocked() { - ExtBuilder::build_with_post().execute_with(|| { - block_account_in_space_1(); - assert_noop!( - _update_post( - None, // From ACCOUNT1 (has default permission to UpdateOwnPosts) - None, - Some(post_update(None, Some(valid_content_ipfs()), Some(true))) - ), - DispatchError::Other(ModerationError::AccountIsBlocked.into()) - ); - }); -} - -// FIXME: uncomment when `update_post` will be able to move post from one space to another -/* -#[test] -fn update_post_should_fail_when_post_is_blocked() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!( - _update_entity_status( - None, - Some(EntityId::Post(POST1)), - Some(SPACE1), - Some(Some(EntityStatus::Blocked)) - ) - ); - assert_noop!( - _update_post( - None, // From ACCOUNT1 (has default permission to UpdateOwnPosts) - Some(POST1), - Some( - post_update( - Some(SPACE1), - None, - None - ) - ) - ), ModerationError::PostIsBlocked.into() - ); - }); -} -*/ - -#[test] -fn create_post_should_work() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!(_create_default_post()); // PostId 1 by ACCOUNT1 which is permitted by default - - // Check storages - assert_eq!(Posts::post_ids_by_space_id(SPACE1), vec![POST1]); - assert_eq!(Posts::next_post_id(), POST2); - - // Check whether data stored correctly - let post = Posts::post_by_id(POST1).unwrap(); - - assert_eq!(post.created.account, ACCOUNT1); - assert!(!post.edited); - assert!(!post.hidden); - - assert_eq!(post.space_id, Some(SPACE1)); - assert_eq!(post.extension, extension_regular_post()); - - assert_eq!(post.content, post_content_ipfs()); - - assert_eq!(post.upvotes_count, 0); - assert_eq!(post.downvotes_count, 0); - }); -} - -#[test] -fn create_post_should_work_when_one_of_roles_is_permitted() { - ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::CreatePosts]).execute_with( - || { - assert_ok!(_create_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // SpaceId 1, - None, // RegularPost extension - None, // Default post content - )); - }, - ); -} - -#[test] -fn create_post_should_fail_when_post_has_no_space_id() { - ExtBuilder::build_with_space().execute_with(|| { - assert_noop!( - _create_post(None, Some(None), None, None), - PostsError::::PostHasNoSpaceId - ); - }); -} - -#[test] -fn create_post_should_fail_when_space_not_found() { - ExtBuilder::build().execute_with(|| { - assert_noop!(_create_default_post(), SpacesError::::SpaceNotFound); - }); -} - -#[test] -fn create_post_should_fail_when_ipfs_cid_is_invalid() { - ExtBuilder::build_with_space().execute_with(|| { - // Try to catch an error creating a regular post with invalid content - assert_noop!( - _create_post(None, None, None, Some(invalid_content_ipfs())), - DispatchError::from(ContentError::InvalidIpfsCid) - ); - }); -} - -#[test] -fn create_post_should_fail_when_account_has_no_permission() { - ExtBuilder::build_with_space().execute_with(|| { - assert_noop!( - _create_post(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None, None), - PostsError::::NoPermissionToCreatePosts - ); - }); -} - -#[test] -fn create_post_should_fail_when_no_right_permission_in_account_roles() { - ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::CreatePosts]).execute_with( - || { - assert_ok!(_delete_default_role()); - - assert_noop!( - _create_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // SpaceId 1, - None, // RegularPost extension - None, // Default post content - ), - PostsError::::NoPermissionToCreatePosts - ); - }, - ); -} - -#[test] -fn update_post_should_work() { - ExtBuilder::build_with_post().execute_with(|| { - let expected_content_ipfs = updated_post_content(); - - // Post update with ID 1 should be fine - assert_ok!(_update_post( - None, // From ACCOUNT1 (has default permission to UpdateOwnPosts) - None, - Some(post_update(None, Some(expected_content_ipfs.clone()), Some(true))) - )); - - // Check whether post updates correctly - let post = Posts::post_by_id(POST1).unwrap(); - assert_eq!(post.space_id, Some(SPACE1)); - assert_eq!(post.content, expected_content_ipfs); - assert!(post.hidden); - }); -} - -fn check_if_post_moved_correctly(moved_post_id: PostId, expected_new_space_id: SpaceId) { - let post: Post = Posts::post_by_id(moved_post_id).unwrap(); // `POST2` is a comment - let new_space_id = post.space_id.unwrap(); - - // Check that space id of the post has been updated from 1 to 2 - assert_eq!(new_space_id, expected_new_space_id); -} - -#[test] -fn move_post_should_work() { - ExtBuilder::build_with_post_and_two_spaces().execute_with(|| { - assert_ok!(_move_post_1_to_space_2()); - - let moved_post_id = POST1; - let old_space_id = SPACE1; - let expected_new_space_id = SPACE2; - check_if_post_moved_correctly(moved_post_id, expected_new_space_id); - - // Check that there are no posts ids in the old space - assert!(Posts::post_ids_by_space_id(old_space_id).is_empty()); - - // Check that there is the post id in the new space - assert_eq!(Posts::post_ids_by_space_id(expected_new_space_id), vec![moved_post_id]); - }); -} - -#[test] -fn move_post_should_work_when_space_id_none() { - ExtBuilder::build_with_post_and_two_spaces().execute_with(|| { - let moved_post_id = POST1; - let old_space_id = SPACE1; // Where post were before moving to `SpaceId:None` - let expected_new_space_id = SPACE2; - - assert_ok!(_move_post_to_nowhere(moved_post_id)); - assert_ok!(_move_post_1_to_space_2()); - - check_if_post_moved_correctly(moved_post_id, expected_new_space_id); - - // Check that there are no posts ids in the old space - assert!(Posts::post_ids_by_space_id(old_space_id).is_empty()); - - // Check that there is the post id in the new space - assert_eq!(Posts::post_ids_by_space_id(expected_new_space_id), vec![moved_post_id]); - }); -} - -#[test] -fn move_hidden_post_should_work() { - ExtBuilder::build_with_post_and_two_spaces().execute_with(|| { - let moved_post_id = POST1; - let old_space_id = SPACE1; - let expected_new_space_id = SPACE2; - - // Hide the post before moving it - assert_ok!(_update_post( - None, - Some(moved_post_id), - Some(post_update(None, None, Some(true))) - )); - - assert_ok!(_move_post_1_to_space_2()); - - check_if_post_moved_correctly(moved_post_id, expected_new_space_id); - - // Check that there are no posts ids in the old space - assert!(Posts::post_ids_by_space_id(old_space_id).is_empty()); - - // Check that there is the post id in the new space - assert_eq!(Posts::post_ids_by_space_id(expected_new_space_id), vec![moved_post_id]); - }); -} - -#[test] -fn move_hidden_post_should_fail_when_post_not_found() { - ExtBuilder::build().execute_with(|| { - // Note that we have not created a post that we are trying to move - assert_noop!(_move_post_1_to_space_2(), PostsError::::PostNotFound); - }); -} - -#[test] -fn move_hidden_post_should_fail_when_provided_space_not_found() { - ExtBuilder::build_with_post().execute_with(|| { - // Note that we have not created a new space #2 before moving the post - assert_noop!(_move_post_1_to_space_2(), SpacesError::::SpaceNotFound); - }); -} - -#[test] -fn move_hidden_post_should_fail_origin_has_no_permission_to_create_posts() { - ExtBuilder::build_with_post().execute_with(|| { - // Create a space #2 from account #2 - assert_ok!(_create_space(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None)); - - // Should not be possible to move the post b/c it's owner is account #1 - // when the space #2 is owned by account #2 - assert_noop!(_move_post_1_to_space_2(), PostsError::::NoPermissionToCreatePosts); - }); -} - -#[test] -fn move_post_should_fail_when_account_has_no_permission() { - ExtBuilder::build_with_post_and_two_spaces().execute_with(|| { - assert_noop!( - _move_post(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None), - PostsError::::NoPermissionToUpdateAnyPost - ); - }); -} - -#[test] -fn move_post_should_fail_when_space_none_and_account_is_not_post_owner() { - ExtBuilder::build_with_post_and_two_spaces().execute_with(|| { - assert_ok!(_move_post_to_nowhere(POST1)); - assert_noop!( - _move_post(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None), - PostsError::::NotAPostOwner - ); - }); -} - -#[test] -fn should_fail_when_trying_to_move_comment() { - ExtBuilder::build_with_comment().execute_with(|| { - assert_ok!(_create_space(None, None, None)); - - // Comments cannot be moved, they stick to their parent post - assert_noop!( - _move_post(None, Some(POST2), None), - PostsError::::CannotUpdateSpaceIdOnComment - ); - }); -} - -#[test] -fn update_post_should_work_after_transfer_space_ownership() { - ExtBuilder::build_with_post().execute_with(|| { - let post_update = post_update(None, Some(updated_post_content()), Some(true)); - - assert_ok!(_transfer_default_space_ownership()); - - // Post update with ID 1 should be fine - assert_ok!(_update_post(None, None, Some(post_update))); - }); -} - -#[test] -fn update_any_post_should_work_when_account_has_default_permission() { - ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::CreatePosts]).execute_with( - || { - let post_update = post_update(None, Some(updated_post_content()), Some(true)); - assert_ok!(_create_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // SpaceId 1 - None, // RegularPost extension - None // Default post content - )); // PostId 1 - - // Post update with ID 1 should be fine - assert_ok!(_update_post( - None, // From ACCOUNT1 (has default permission to UpdateAnyPosts as SpaceOwner) - Some(POST1), - Some(post_update) - )); - }, - ); -} - -#[test] -fn update_any_post_should_work_when_one_of_roles_is_permitted() { - ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::UpdateAnyPost]).execute_with( - || { - let post_update = post_update(None, Some(updated_post_content()), Some(true)); - assert_ok!(_create_default_post()); // PostId 1 - - // Post update with ID 1 should be fine - assert_ok!(_update_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - Some(POST1), - Some(post_update) - )); - }, - ); -} - -#[test] -fn update_post_should_fail_when_no_updates_for_post_provided() { - ExtBuilder::build_with_post().execute_with(|| { - // Try to catch an error updating a post with no changes - assert_noop!(_update_post(None, None, None), PostsError::::NoUpdatesForPost); - }); -} - -#[test] -fn update_post_should_fail_when_post_not_found() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_create_space(None, None, None)); // SpaceId 2 - - // Try to catch an error updating a post with wrong post ID - assert_noop!( - _update_post( - None, - Some(POST2), - Some(post_update( - // FIXME: when Post's `space_id` update is fully implemented - None, /* Some(SPACE2) */ - None, - Some(true) /* None */ - )) - ), - PostsError::::PostNotFound - ); - }); -} - -#[test] -fn update_post_should_fail_when_account_has_no_permission_to_update_any_post() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_create_space(None, None, None)); // SpaceId 2 - - // Try to catch an error updating a post with different account - assert_noop!( - _update_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, - Some(post_update( - // FIXME: when Post's `space_id` update is fully implemented - None, /* Some(SPACE2) */ - None, - Some(true) /* None */ - )) - ), - PostsError::::NoPermissionToUpdateAnyPost - ); - }); -} - -#[test] -fn update_post_should_fail_when_ipfs_cid_is_invalid() { - ExtBuilder::build_with_post().execute_with(|| { - // Try to catch an error updating a post with invalid content - assert_noop!( - _update_post(None, None, Some(post_update(None, Some(invalid_content_ipfs()), None))), - DispatchError::from(ContentError::InvalidIpfsCid) - ); - }); -} - -#[test] -fn update_post_should_fail_when_no_right_permission_in_account_roles() { - ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::UpdateAnyPost]).execute_with( - || { - let post_update = post_update(None, Some(updated_post_content()), Some(true)); - assert_ok!(_create_default_post()); - // PostId 1 - assert_ok!(_delete_default_role()); - - // Post update with ID 1 should be fine - assert_noop!( - _update_post(Some(RuntimeOrigin::signed(ACCOUNT2)), Some(POST1), Some(post_update)), - PostsError::::NoPermissionToUpdateAnyPost - ); - }, - ); -} - -// TODO: refactor or remove. Deprecated tests -// Find public post ids tests -// -------------------------------------------------------------------------------------------- -/*#[test] -fn find_public_post_ids_in_space_should_work() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_create_post(None, Some(Some(SPACE1)), None, None)); - - let post_ids = Posts::find_public_post_ids_in_space(SPACE1, 0, 3); - assert_eq!(post_ids, vec![POST1, POST2]); - }); -} - -#[test] -fn find_public_post_ids_in_space_should_work_with_zero_offset() { - ExtBuilder::build_with_post().execute_with(|| { - let post_ids = Posts::find_public_post_ids_in_space(SPACE1, 0, 1); - assert_eq!(post_ids, vec![POST1]); - }); -} - -#[test] -fn find_public_post_ids_in_space_should_work_with_zero_limit() { - ExtBuilder::build_with_post().execute_with(|| { - let post_ids = Posts::find_public_post_ids_in_space(SPACE1, 1, 0); - assert_eq!(post_ids, vec![POST1]); - }); -} - -#[test] -fn find_public_post_ids_in_space_should_work_with_zero_offset_and_zero_limit() { - ExtBuilder::build_with_post().execute_with(|| { - let post_ids = Posts::find_public_post_ids_in_space(SPACE1, 0, 0); - assert_eq!(post_ids, vec![]); - }); -} - -// Find unlisted post ids tests -// -------------------------------------------------------------------------------------------- - -#[test] -fn find_unlisted_post_ids_in_space_should_work() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_create_post(None, Some(Some(SPACE1)), None, None)); - assert_ok!( - _update_post( - None, - None, - Some( - post_update( - None, - Some(Content::None), - Some(true)) - ) - ) - ); - assert_ok!( - _update_post( - None, - Some(POST2), - Some( - post_update( - None, - Some(Content::None), - Some(true)) - ) - ) - ); - - let post_ids = Posts::find_unlisted_post_ids_in_space(SPACE1, 0, 3); - assert_eq!(post_ids, vec![POST1, POST2]); - }); -} - -#[test] -fn find_unlisted_post_ids_in_space_should_work_with_zero_offset() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!( - _update_post( - None, - None, - Some( - post_update( - None, - Some(Content::None), - Some(true)) - ) - ) - ); - - let post_ids = Posts::find_unlisted_post_ids_in_space(SPACE1, 0, 1); - assert_eq!(post_ids, vec![POST1]); - }); -} - -#[test] -fn find_unlisted_post_ids_in_space_should_work_with_zero_limit() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!( - _update_post( - None, - None, - Some( - post_update( - None, - Some(Content::None), - Some(true)) - ) - ) - ); - - let post_ids = Posts::find_unlisted_post_ids_in_space(SPACE1, 1, 0); - assert_eq!(post_ids, vec![POST1]); - }); -} - -#[test] -fn find_unlisted_post_ids_in_space_should_work_with_zero_offset_and_zero_limit() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!( - _update_post( - None, - None, - Some( - post_update( - None, - Some(Content::None), - Some(true)) - ) - ) - ); - - let post_ids = Posts::find_unlisted_post_ids_in_space(SPACE1, 0, 0); - assert_eq!(post_ids, vec![]); - }); -}*/ -// -------------------------------------------------------------------------------------------- diff --git a/pallets/posts/tests/src/shared_posts_tests.rs b/pallets/posts/tests/src/shared_posts_tests.rs deleted file mode 100644 index b4d1825..0000000 --- a/pallets/posts/tests/src/shared_posts_tests.rs +++ /dev/null @@ -1,180 +0,0 @@ -use frame_support::{assert_noop, assert_ok}; - -use pallet_permissions::SpacePermission as SP; -use pallet_posts::Error as PostsError; - -use crate::{mock::*, tests_utils::*}; - -#[test] -fn share_post_should_work() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_create_space(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None)); // SpaceId 2 by ACCOUNT2 - - assert_ok!(_create_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - Some(Some(SPACE2)), - Some(extension_shared_post(POST1)), - None - )); // Share PostId 1 on SpaceId 2 by ACCOUNT2 which is permitted by default in both spaces - - // Check storages - assert_eq!(Posts::post_ids_by_space_id(SPACE1), vec![POST1]); - assert_eq!(Posts::post_ids_by_space_id(SPACE2), vec![POST2]); - assert_eq!(Posts::next_post_id(), POST3); - - assert_eq!(Posts::shared_post_ids_by_original_post_id(POST1), vec![POST2]); - - let shared_post = Posts::post_by_id(POST2).unwrap(); - - assert_eq!(shared_post.space_id, Some(SPACE2)); - assert_eq!(shared_post.created.account, ACCOUNT2); - assert_eq!(shared_post.extension, extension_shared_post(POST1)); - }); -} - -#[test] -fn share_post_should_work_when_one_of_roles_is_permitted() { - ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::CreatePosts]).execute_with( - || { - assert_ok!(_create_space( - None, // From ACCOUNT1 - None, // With default space content, - None - )); - // SpaceId 2 - assert_ok!(_create_post( - None, // From ACCOUNT1 - Some(Some(SPACE2)), - None, // With RegularPost extension - None // With default post content - )); // PostId 1 on SpaceId 2 - - assert_ok!(_create_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - Some(Some(SPACE1)), - Some(extension_shared_post(POST1)), - None - )); // Share PostId 1 on SpaceId 1 by ACCOUNT2 which is permitted by RoleId 1 from ext - }, - ); -} - -#[test] -fn share_post_should_work_for_share_own_post_in_same_own_space() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_create_post( - Some(RuntimeOrigin::signed(ACCOUNT1)), - Some(Some(SPACE1)), - Some(extension_shared_post(POST1)), - None - )); // Share PostId 1 - - // Check storages - assert_eq!(Posts::post_ids_by_space_id(SPACE1), vec![POST1, POST2]); - assert_eq!(Posts::next_post_id(), POST3); - - assert_eq!(Posts::shared_post_ids_by_original_post_id(POST1), vec![POST2]); - - let shared_post = Posts::post_by_id(POST2).unwrap(); - assert_eq!(shared_post.space_id, Some(SPACE1)); - assert_eq!(shared_post.created.account, ACCOUNT1); - assert_eq!(shared_post.extension, extension_shared_post(POST1)); - }); -} - -#[test] -fn share_post_should_fail_when_original_post_not_found() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!(_create_space(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None)); // SpaceId 2 by ACCOUNT2 - - // Skipped creating PostId 1 - assert_noop!( - _create_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - Some(Some(SPACE2)), - Some(extension_shared_post(POST1)), - None - ), - PostsError::::OriginalPostNotFound - ); - }); -} - -#[test] -fn share_post_should_fail_when_trying_to_share_shared_post() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_create_space(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None)); // SpaceId 2 by ACCOUNT2 - - assert_ok!(_create_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - Some(Some(SPACE2)), - Some(extension_shared_post(POST1)), - None - )); - - // Try to share post with extension SharedPost - assert_noop!( - _create_post( - Some(RuntimeOrigin::signed(ACCOUNT1)), - Some(Some(SPACE1)), - Some(extension_shared_post(POST2)), - None - ), - PostsError::::CannotShareSharedPost - ); - }); -} - -#[test] -fn share_post_should_fail_when_account_has_no_permission_to_create_posts_in_new_space() { - ExtBuilder::build_with_post().execute_with(|| { - assert_ok!(_create_space( - Some(RuntimeOrigin::signed(ACCOUNT1)), - None, // Default space content, - None - )); // SpaceId 2 by ACCOUNT1 - - // Try to share post with extension SharedPost - assert_noop!( - _create_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - Some(Some(SPACE2)), - Some(extension_shared_post(POST1)), - None - ), - PostsError::::NoPermissionToCreatePosts - ); - }); -} - -#[test] -fn share_post_should_fail_when_no_right_permission_in_account_roles() { - ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::CreatePosts]).execute_with( - || { - assert_ok!(_create_space( - None, // From ACCOUNT1 - None, // With default space content - None - )); - // SpaceId 2 - assert_ok!(_create_post( - None, // From ACCOUNT1 - Some(Some(SPACE2)), - None, // With RegularPost extension - None // With default post content - )); // PostId 1 on SpaceId 2 - - assert_ok!(_delete_default_role()); - - assert_noop!( - _create_post( - Some(RuntimeOrigin::signed(ACCOUNT2)), - Some(Some(SPACE1)), - Some(extension_shared_post(POST1)), - None - ), - PostsError::::NoPermissionToCreatePosts - ); - }, - ); -} diff --git a/pallets/posts/tests/src/tests_utils.rs b/pallets/posts/tests/src/tests_utils.rs deleted file mode 100644 index 98e9b4c..0000000 --- a/pallets/posts/tests/src/tests_utils.rs +++ /dev/null @@ -1,488 +0,0 @@ -use std::{ - cell::RefCell, - collections::HashMap, - hash::{Hash, Hasher}, -}; - -use frame_support::{assert_ok, pallet_prelude::*}; -use sp_core::storage::Storage; -use sp_io::TestExternalities; - -use pallet_permissions::{SpacePermission as SP, SpacePermission, SpacePermissions}; -use pallet_posts::{Comment, PostExtension, PostUpdate}; -use pallet_spaces::types::SpaceUpdate; -use subsocial_support::{ - mock_functions::*, - traits::{IsAccountBlocked, IsContentBlocked, IsPostBlocked, IsSpaceBlocked}, - Content, PostId, SpaceId, User, -}; - -use crate::mock::*; - -////// Ext Builder - -pub struct ExtBuilder; - -impl ExtBuilder { - fn configure_storages(storage: &mut Storage) { - let mut accounts = Vec::new(); - for account in ACCOUNT1..=ACCOUNT2 { - accounts.push(account); - } - - let _ = pallet_balances::GenesisConfig:: { - balances: accounts.iter().cloned().map(|k| (k, 100)).collect(), - } - .assimilate_storage(storage); - } - - /// Default ext configuration with BlockNumber 1 - pub fn build() -> TestExternalities { - let mut storage = frame_system::GenesisConfig::default().build_storage::().unwrap(); - - Self::configure_storages(&mut storage); - - let mut ext = TestExternalities::from(storage); - ext.execute_with(|| System::set_block_number(1)); - - ext - } - - fn add_default_space() { - assert_ok!(_create_default_space()); - } - - fn add_another_space() { - assert_ok!(_create_space_with_content(another_space_content_ipfs())); - } - - fn add_post() { - Self::add_default_space(); - assert_ok!(_create_default_post()); - } - - fn add_comment() { - Self::add_post(); - assert_ok!(_create_default_comment()); - } - - /// Custom ext configuration with SpaceId 1 and BlockNumber 1 - pub fn build_with_space() -> TestExternalities { - let mut ext = Self::build(); - ext.execute_with(Self::add_default_space); - ext - } - - /// Custom ext configuration with SpaceId 1, PostId 1 and BlockNumber 1 - pub fn build_with_post() -> TestExternalities { - let mut ext = Self::build(); - ext.execute_with(Self::add_post); - ext - } - - /// Custom ext configuration with SpaceId 1, PostId 1, PostId 2 (as comment) and BlockNumber 1 - pub fn build_with_comment() -> TestExternalities { - let mut ext = Self::build(); - ext.execute_with(Self::add_comment); - ext - } - - /// Custom ext configuration with SpaceId 1-2, PostId 1 where BlockNumber 1 - pub fn build_with_post_and_two_spaces() -> TestExternalities { - let mut ext = Self::build_with_post(); - ext.execute_with(Self::add_another_space); - ext - } - - /// Custom ext configuration with specified permissions granted (includes SpaceId 1) - pub fn build_with_a_few_roles_granted_to_account2(perms: Vec) -> TestExternalities { - let mut ext = Self::build_with_space(); - - ext.execute_with(|| { - let user = User::Account(ACCOUNT2); - assert_ok!(_create_role(None, None, None, None, Some(perms))); - // RoleId 1 - assert_ok!(_create_default_role()); // RoleId 2 - - assert_ok!(_grant_role(None, Some(ROLE1), Some(vec![user.clone()]))); - assert_ok!(_grant_role(None, Some(ROLE2), Some(vec![user]))); - }); - - ext - } -} - -////// Consts - -pub(crate) const ACCOUNT1: AccountId = 1; -pub(crate) const ACCOUNT2: AccountId = 2; - -pub(crate) const SPACE1: SpaceId = 1001; -pub(crate) const SPACE2: SpaceId = 1002; - -pub(crate) const POST1: PostId = 1; -pub(crate) const POST2: PostId = 2; -pub(crate) const POST3: PostId = 3; - -type RoleId = u64; - -pub(crate) const ROLE1: RoleId = 1; -pub(crate) const ROLE2: RoleId = 2; - -////// Moderation Utils - -// Moderation pallet mocks - -/* ------------------------------------------------------------------------------------------------ */ -// Moderation tests - -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug)] -pub enum EntityId { - Content(Content), - Account(AccountId), - Space(SpaceId), - Post(PostId), -} - -impl Hash for EntityId { - fn hash(&self, state: &mut H) { - match self { - EntityId::Content(content) => match content { - Content::None => 0.hash(state), - Content::Other(content) => content.hash(state), - Content::IPFS(content) => content.hash(state), - }, - EntityId::Account(account) => account.hash(state), - EntityId::Space(space) => space.hash(state), - EntityId::Post(post) => post.hash(state), - } - } -} - -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, Hash)] -pub enum EntityStatus { - Allowed, - Blocked, -} - -thread_local! { - pub static MOCK_MODERATION_STATE: RefCell> = RefCell::new(Default::default()); -} -pub struct MockModeration; - -impl MockModeration { - fn set_entity_status(entity: EntityId, space: SpaceId, status: EntityStatus) { - MOCK_MODERATION_STATE.with(|mock_moderation_state| { - let mut mock_moderation_state = mock_moderation_state.borrow_mut(); - mock_moderation_state.insert((entity, space), status); - }); - } - - fn get_entity_status(id: EntityId, scope: SpaceId) -> Option { - MOCK_MODERATION_STATE.with(|mock_moderation_state| { - let mock_moderation_state = mock_moderation_state.borrow(); - let status = mock_moderation_state.get(&(id, scope)).cloned(); - status - }) - } - - fn is_allowed_entity(id: EntityId, scope: SpaceId) -> bool { - Self::get_entity_status(id, scope).unwrap_or(EntityStatus::Allowed) == EntityStatus::Allowed - } - - fn is_blocked_entity(id: EntityId, scope: SpaceId) -> bool { - Self::get_entity_status(id, scope) == Some(EntityStatus::Blocked) - } -} - -impl IsPostBlocked for MockModeration { - fn is_blocked_post(post_id: PostId, scope: SpaceId) -> bool { - Self::is_blocked_entity(EntityId::Post(post_id), scope) - } - - fn is_allowed_post(post_id: PostId, scope: SpaceId) -> bool { - Self::is_allowed_entity(EntityId::Post(post_id), scope) - } -} - -impl IsAccountBlocked for MockModeration { - fn is_blocked_account(account: AccountId, scope: SpaceId) -> bool { - Self::is_blocked_entity(EntityId::Account(account), scope) - } - - fn is_allowed_account(account: AccountId, scope: SpaceId) -> bool { - Self::is_allowed_entity(EntityId::Account(account), scope) - } -} - -impl IsSpaceBlocked for MockModeration { - fn is_blocked_space(space_id: SpaceId, scope: SpaceId) -> bool { - Self::is_blocked_entity(EntityId::Space(space_id), scope) - } - - fn is_allowed_space(space_id: SpaceId, scope: SpaceId) -> bool { - Self::is_allowed_entity(EntityId::Space(space_id), scope) - } -} - -impl IsContentBlocked for MockModeration { - fn is_blocked_content(content: Content, scope: SpaceId) -> bool { - Self::is_blocked_entity(EntityId::Content(content), scope) - } - - fn is_allowed_content(content: Content, scope: SpaceId) -> bool { - Self::is_allowed_entity(EntityId::Content(content), scope) - } -} - -pub(crate) fn block_account_in_space_1() { - MockModeration::set_entity_status(EntityId::Account(ACCOUNT1), SPACE1, EntityStatus::Blocked); -} - -pub(crate) fn block_content_in_space_1() { - MockModeration::set_entity_status( - EntityId::Content(valid_content_ipfs()), - SPACE1, - EntityStatus::Blocked, - ); -} - -///////////// Space Utils - -pub(crate) fn space_content_ipfs() -> Content { - Content::IPFS(b"bafyreib3mgbou4xln42qqcgj6qlt3cif35x4ribisxgq7unhpun525l54e".to_vec()) -} - -pub(crate) fn another_space_content_ipfs() -> Content { - Content::IPFS(b"bafyrelt3cif35x4ribisxgq7unhpun525l54eib3mgbou4xln42qqcgj6q".to_vec()) -} - -pub(crate) fn space_update(content: Option, hidden: Option) -> SpaceUpdate { - SpaceUpdate { content, hidden, permissions: None } -} - -pub(crate) fn _create_default_space() -> DispatchResult { - _create_space(None, None, None) -} - -pub(crate) fn _create_space( - origin: Option, - content: Option, - permissions: Option>, -) -> DispatchResult { - Spaces::create_space( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - content.unwrap_or_else(space_content_ipfs), - permissions.unwrap_or_default(), - ) -} - -pub(crate) fn _create_space_with_content(content: Content) -> DispatchResult { - _create_space(None, Some(content), None) -} - -pub(crate) fn _update_space( - origin: Option, - space_id: Option, - update: Option, -) -> DispatchResult { - Spaces::update_space( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - space_id.unwrap_or(SPACE1), - update.unwrap_or_else(|| space_update(None, None)), - ) -} - -///////////// Post Utils - -pub(crate) fn post_content_ipfs() -> Content { - Content::IPFS(b"bafyreidzue2dtxpj6n4x5mktrt7las5wz5diqma47zr25uau743dhe76we".to_vec()) -} - -pub(crate) fn updated_post_content() -> Content { - Content::IPFS(b"bafyreifw4omlqpr3nqm32bueugbodkrdne7owlkxgg7ul2qkvgrnkt3g3u".to_vec()) -} - -pub(crate) fn post_update( - space_id: Option, - content: Option, - hidden: Option, -) -> PostUpdate { - PostUpdate { space_id, content, hidden } -} - -pub(crate) fn comment_content_ipfs() -> Content { - Content::IPFS(b"bafyreib6ceowavccze22h2x4yuwagsnym2c66gs55mzbupfn73kd6we7eu".to_vec()) -} - -pub(crate) fn reply_content_ipfs() -> Content { - Content::IPFS(b"QmYA2fn8cMbVWo4v95RwcwJVyQsNtnEwHerfWR8UNtEwoE".to_vec()) -} - -pub(crate) fn extension_regular_post() -> PostExtension { - PostExtension::RegularPost -} - -pub(crate) fn extension_comment(parent_id: Option, root_post_id: PostId) -> PostExtension { - PostExtension::Comment(Comment { parent_id, root_post_id }) -} - -pub(crate) fn extension_shared_post(original_post_id: PostId) -> PostExtension { - PostExtension::SharedPost(original_post_id) -} - -pub(crate) fn _create_default_post() -> DispatchResult { - _create_post(None, None, None, None) -} - -pub(crate) fn _create_post( - origin: Option, - space_id_opt: Option>, - extension: Option, - content: Option, -) -> DispatchResult { - Posts::create_post( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - space_id_opt.unwrap_or(Some(SPACE1)), - extension.unwrap_or_else(extension_regular_post), - content.unwrap_or_else(post_content_ipfs), - ) -} - -pub(crate) fn _update_post( - origin: Option, - post_id: Option, - update: Option, -) -> DispatchResult { - Posts::update_post( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - post_id.unwrap_or(POST1), - update.unwrap_or_else(|| post_update(None, None, None)), - ) -} - -pub(crate) fn _move_post_1_to_space_2() -> DispatchResult { - _move_post(None, None, None) -} - -/// Move the post out of this space to nowhere (space = None). -pub(crate) fn _move_post_to_nowhere(post_id: PostId) -> DispatchResult { - _move_post(None, Some(post_id), Some(None)) -} - -pub(crate) fn _move_post( - origin: Option, - post_id: Option, - new_space_id: Option>, -) -> DispatchResult { - Posts::move_post( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - post_id.unwrap_or(POST1), - new_space_id.unwrap_or(Some(SPACE2)), - ) -} - -pub(crate) fn _create_default_comment() -> DispatchResult { - _create_comment(None, None, None, None) -} - -pub(crate) fn _create_comment( - origin: Option, - post_id: Option, - parent_id: Option>, - content: Option, -) -> DispatchResult { - _create_post( - origin, - Some(None), - Some(extension_comment(parent_id.unwrap_or_default(), post_id.unwrap_or(POST1))), - Some(content.unwrap_or_else(comment_content_ipfs)), - ) -} - -pub(crate) fn _update_comment( - origin: Option, - post_id: Option, - update: Option, -) -> DispatchResult { - _update_post( - origin, - Some(post_id.unwrap_or(POST2)), - Some(update.unwrap_or_else(|| post_update(None, Some(reply_content_ipfs()), None))), - ) -} - -/////// Roles utils - -pub(crate) fn default_role_content_ipfs() -> Content { - Content::IPFS(b"QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD4".to_vec()) -} - -pub fn _create_default_role() -> DispatchResult { - _create_role(None, None, None, None, None) -} - -pub fn _create_role( - origin: Option, - space_id: Option, - time_to_live: Option>, - content: Option, - permissions: Option>, -) -> DispatchResult { - // TODO: remove - Roles::create_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - space_id.unwrap_or(SPACE1), - time_to_live.unwrap_or_default(), // Should return 'None' - content.unwrap_or_else(default_role_content_ipfs), - permissions.unwrap_or_else(permission_set_default), - ) -} - -pub fn _grant_role( - origin: Option, - role_id: Option, - users: Option>>, -) -> DispatchResult { - Roles::grant_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - role_id.unwrap_or(ROLE1), - users.unwrap_or_else(|| vec![User::Account(ACCOUNT2)]), - ) -} - -pub fn _delete_default_role() -> DispatchResult { - _delete_role(None, None) -} - -pub fn _delete_role(origin: Option, role_id: Option) -> DispatchResult { - let users_count = Roles::users_by_role_id(role_id.unwrap_or(ROLE1)).len(); - Roles::delete_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - role_id.unwrap_or(ROLE1), - users_count as u32, - ) -} - -/////// Permissions utils - -/// Permissions Set that includes next permission: ManageRoles -pub(crate) fn permission_set_default() -> Vec { - vec![SP::ManageRoles] -} - -pub(crate) fn _transfer_default_space_ownership() -> DispatchResult { - _transfer_space_ownership(None, None, None) -} - -pub(crate) fn _transfer_space_ownership( - origin: Option, - space_id: Option, - transfer_to: Option, -) -> DispatchResult { - SpaceOwnership::transfer_space_ownership( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - space_id.unwrap_or(SPACE1), - transfer_to.unwrap_or(ACCOUNT2), - ) -} diff --git a/pallets/roles/Cargo.toml b/pallets/roles/Cargo.toml deleted file mode 100644 index c863381..0000000 --- a/pallets/roles/Cargo.toml +++ /dev/null @@ -1,57 +0,0 @@ -[package] -name = 'pallet-roles' -version = '0.1.7' -authors = ['DappForce '] -edition = '2021' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Roles management pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[features] -default = ['std'] -runtime-benchmarks = [ - 'frame-benchmarking/runtime-benchmarks', - 'pallet-spaces', -] -std = [ - 'codec/std', - 'scale-info/std', - 'frame-benchmarking/std', - 'frame-support/std', - 'frame-system/std', - 'pallet-balances/std', - 'pallet-timestamp/std', - 'sp-runtime/std', - 'sp-std/std', - 'pallet-permissions/std', - 'subsocial-support/std', -] -try-runtime = ['frame-support/try-runtime'] - -[dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } - -# Local dependencies -pallet-permissions = { default-features = false, path = '../permissions' } -pallet-spaces = { optional = true, default-features = false, path = '../spaces' } -subsocial-support = { default-features = false, path = '../support' } - -# Substrate dependencies -frame-benchmarking = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false, optional = true } -frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } - -[dev-dependencies] -serde = { version = '1.0.152' } - -pallet-balances = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-core = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-io = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -pallet-spaces = { default-features = false, path = '../spaces' } diff --git a/pallets/roles/rpc/Cargo.toml b/pallets/roles/rpc/Cargo.toml deleted file mode 100644 index 25c8226..0000000 --- a/pallets/roles/rpc/Cargo.toml +++ /dev/null @@ -1,51 +0,0 @@ -[package] -name = 'roles-rpc' -version = '0.7.3' -authors = ['DappForce '] -edition = '2018' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'RPC methods for the roles pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[dependencies.serde] -optional = true -features = ['derive'] -version = '1.0.119' - -[dependencies.codec] -default-features = false -features = ['derive'] -package = 'parity-scale-codec' -version = '2.0.0' - -[dependencies] -jsonrpc-core = '18.0.0' -jsonrpc-core-client = '18.0.0' -jsonrpc-derive = '18.0.0' - -# Local dependencies -pallet-permissions = { default-features = false, path = '../../permissions' } -pallet-utils = { default-features = false, path = '../../utils' } - -# Custom Runtime API -roles-runtime-api = { default-features = false, path = 'runtime-api' } - -# Substrate dependencies -sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-blockchain = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-rpc = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } - -[features] -default = ['std'] -std = [ - 'serde', - 'sp-runtime/std', - 'sp-api/std', - 'roles-runtime-api/std', - 'pallet-permissions/std', - 'pallet-utils/std', -] diff --git a/pallets/roles/rpc/runtime-api/Cargo.toml b/pallets/roles/rpc/runtime-api/Cargo.toml deleted file mode 100644 index 0dd3ab5..0000000 --- a/pallets/roles/rpc/runtime-api/Cargo.toml +++ /dev/null @@ -1,43 +0,0 @@ -[package] -name = 'roles-runtime-api' -version = '0.7.3' -authors = ['DappForce '] -edition = '2018' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Runtime API definition for the roles pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[dependencies.serde] -optional = true -features = ["derive"] -version = "1.0.119" - -[dependencies.codec] -default-features = false -features = ['derive'] -package = 'parity-scale-codec' -version = '2.0.0' - -[dependencies] -# Local dependencies -pallet-permissions = { default-features = false, path = '../../../permissions' } -pallet-utils = { default-features = false, path = '../../../utils' } - -# Substrate dependencies -sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } - -[features] -default = ['std'] -std = [ - 'serde', - 'sp-api/std', - 'sp-std/std', - 'sp-runtime/std', - 'pallet-permissions/std', - 'pallet-utils/std', -] diff --git a/pallets/roles/rpc/runtime-api/src/lib.rs b/pallets/roles/rpc/runtime-api/src/lib.rs deleted file mode 100644 index 551beab..0000000 --- a/pallets/roles/rpc/runtime-api/src/lib.rs +++ /dev/null @@ -1,18 +0,0 @@ -#![cfg_attr(not(feature = "std"), no_std)] - -use codec::Codec; -use sp_std::vec::Vec; -use pallet_utils::SpaceId; -use pallet_permissions::SpacePermission; - -sp_api::decl_runtime_apis! { - pub trait RolesApi where - AccountId: Codec - { - fn get_space_permissions_by_account(account: AccountId, space_id: SpaceId) -> Vec; - - fn get_accounts_with_any_role_in_space(space_id: SpaceId) -> Vec; - - fn get_space_ids_for_account_with_any_role(account_id: AccountId) -> Vec; - } -} diff --git a/pallets/roles/rpc/src/lib.rs b/pallets/roles/rpc/src/lib.rs deleted file mode 100644 index 35991b5..0000000 --- a/pallets/roles/rpc/src/lib.rs +++ /dev/null @@ -1,96 +0,0 @@ -use std::sync::Arc; -use codec::Codec; -use sp_blockchain::HeaderBackend; -use sp_runtime::{generic::BlockId, traits::Block as BlockT}; -use jsonrpc_core::Result; -use jsonrpc_derive::rpc; -use sp_api::ProvideRuntimeApi; -use pallet_utils::{SpaceId, rpc::map_rpc_error}; -use pallet_permissions::SpacePermission; - -pub use roles_runtime_api::RolesApi as RolesRuntimeApi; - -#[rpc] -pub trait RolesApi { - #[rpc(name = "roles_getSpacePermissionsByAccount")] - fn get_space_permissions_by_account( - &self, - at: Option, - account: AccountId, - space_id: SpaceId - ) -> Result>; - - #[rpc(name = "roles_getAccountsWithAnyRoleInSpace")] - fn get_accounts_with_any_role_in_space( - &self, - at: Option, - space_id: SpaceId - ) -> Result>; - - #[rpc(name = "roles_getSpaceIdsForAccountWithAnyRole")] - fn get_space_ids_for_account_with_any_role( - &self, - at: Option, - account_id: AccountId - ) -> Result>; -} - -pub struct Roles { - client: Arc, - _marker: std::marker::PhantomData, -} - -impl Roles { - pub fn new(client: Arc) -> Self { - Self { - client, - _marker: Default::default(), - } - } -} - -impl RolesApi<::Hash, AccountId> - for Roles -where - Block: BlockT, - AccountId: Codec, - C: Send + Sync + 'static + ProvideRuntimeApi + HeaderBackend, - C::Api: RolesRuntimeApi, -{ - fn get_space_permissions_by_account( - &self, at: - Option<::Hash>, - account: AccountId, - space_id: SpaceId - ) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_space_permissions_by_account(&at, account, space_id); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_accounts_with_any_role_in_space( - &self, at: - Option<::Hash>, - space_id: SpaceId - ) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_accounts_with_any_role_in_space(&at, space_id); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_space_ids_for_account_with_any_role( - &self, at: - Option<::Hash>, - account_id: AccountId - ) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_space_ids_for_account_with_any_role(&at, account_id); - runtime_api_result.map_err(map_rpc_error) - } -} diff --git a/pallets/roles/src/benchmarking.rs b/pallets/roles/src/benchmarking.rs deleted file mode 100644 index f103260..0000000 --- a/pallets/roles/src/benchmarking.rs +++ /dev/null @@ -1,146 +0,0 @@ -//! Roles pallet benchmarking. - -#![cfg(feature = "runtime-benchmarks")] - -// FIXME: refactor once SpacesInterface is added. - -use super::*; -use frame_benchmarking::{account, benchmarks}; -use frame_support::dispatch::DispatchError; -use frame_system::RawOrigin; -use pallet_permissions::SpacePermission as SP; -use pallet_spaces::types::Space; -use sp_std::{prelude::Vec, vec}; -use subsocial_support::{Content, User}; -use subsocial_support::mock_functions::{valid_content_ipfs, another_valid_content_ipfs}; - -fn create_dummy_space( - origin: RawOrigin, -) -> Result, DispatchError> { - let space_id = pallet_spaces::NextSpaceId::::get(); - - pallet_spaces::Pallet::::create_space(origin.into(), Content::None, None)?; - - let space = pallet_spaces::SpaceById::::get(space_id) - .ok_or(DispatchError::Other("Space not found"))?; - - Ok(space) -} - -fn dummy_list_of_users(num_of_users: u32) -> Vec> { - let mut users_to_grant = Vec::>::new(); - - for i in 1..num_of_users + 1 { - let user = account("user", i * 2 - 1, i * 2); - users_to_grant.push(User::Account(user)); - } - - users_to_grant -} - -fn create_dummy_role( - origin: RawOrigin, - space_id: SpaceId, - num_of_users: u32, -) -> Result<(Role, Vec>), DispatchError> { - let role_id = NextRoleId::::get(); - - Pallet::::create_role( - origin.clone().into(), - space_id, - Some(100u32.into()), - Content::None, - vec![SP::ManageRoles], - )?; - - let role = RoleById::::get(role_id).ok_or(DispatchError::Other("Role not found"))?; - - let users_to_grant = dummy_list_of_users::(num_of_users); - - if !users_to_grant.is_empty() { - Pallet::::grant_role(origin.into(), role.id, users_to_grant.clone())?; - } - - Ok((role, users_to_grant)) -} - -benchmarks! { - where_clause { where T: pallet_spaces::Config } - - create_role { - let caller_origin = RawOrigin::Signed(account::("Acc1", 1, 0)); - let space = create_dummy_space::(caller_origin.clone())?; - let time_to_live: Option = Some(100u32.into()); - let content = valid_content_ipfs(); - let perms = vec![SP::ManageRoles]; - let role_id = NextRoleId::::get(); - }: _(caller_origin, space.id, time_to_live, content, perms) - verify { - let role = RoleById::::get(role_id).unwrap(); - let space_roles_ids = RoleIdsBySpaceId::::get(space.id); - - ensure!(role.id == role_id, "Role id doesn't match"); - ensure!(space_roles_ids.contains(&role_id), "Role id not in space roles"); - } - - update_role { - let caller_origin = RawOrigin::Signed(account::("Acc1", 1, 0)); - let space = create_dummy_space::(caller_origin.clone())?; - let (role, _) = create_dummy_role::(caller_origin.clone(), space.id, 10)?; - - ensure!(!role.disabled, "Role should be enabled"); - - let update = RoleUpdate { - disabled: true.into(), - content: another_valid_content_ipfs().into(), - permissions: None - }; - }: _(caller_origin, role.id, update) - verify { - let role = RoleById::::get(role.id).unwrap(); - ensure!(role.disabled, "Role should be disabled"); - } - - delete_role { - let x in 0..T::MaxUsersToProcessPerDeleteRole::get().into(); - let caller_origin = RawOrigin::Signed(account::("Acc1", 1, 0)); - let space = create_dummy_space::(caller_origin.clone())?; - let (role, _) = create_dummy_role::(caller_origin.clone(), space.id, x)?; - }: _(caller_origin, role.id, x) - verify { - let deleted = RoleById::::get(role.id).is_none(); - ensure!(deleted, "Role should be deleted"); - } - - grant_role { - let x in 1..500; - let caller_origin = RawOrigin::Signed(account::("Acc1", 1, 0)); - let space = create_dummy_space::(caller_origin.clone())?; - let (role, _) = create_dummy_role::(caller_origin.clone(), space.id, 0)?; - - let users_to_grant = dummy_list_of_users::(x); - }: _(caller_origin, role.id, users_to_grant.clone()) - verify { - let granted_users = UsersByRoleId::::get(role.id); - for user in users_to_grant { - ensure!(granted_users.contains(&user), "Role should be granted"); - } - } - - revoke_role { - let x in 1..500; - let caller_origin = RawOrigin::Signed(account::("Acc1", 1, 0)); - let space = create_dummy_space::(caller_origin.clone())?; - let (role, users_to_revoke) = create_dummy_role::(caller_origin.clone(), space.id, x)?; - }: _(caller_origin, role.id, users_to_revoke) - verify { - let granted_users = UsersByRoleId::::get(role.id); - ensure!(granted_users.is_empty(), "Role should have zero users"); - } - - impl_benchmark_test_suite!( - Pallet, - crate::mock::ExtBuilder::build(), - crate::mock::Test, - ); -} diff --git a/pallets/roles/src/functions.rs b/pallets/roles/src/functions.rs deleted file mode 100644 index 5cd98e1..0000000 --- a/pallets/roles/src/functions.rs +++ /dev/null @@ -1,187 +0,0 @@ -use super::*; - -use frame_support::dispatch::DispatchError; -use pallet_permissions::SpacePermissionsContext; - -impl Pallet { - /// Check that there is a `Role` with such `role_id` in the storage - /// or return`RoleNotFound` error. - pub fn ensure_role_exists(role_id: RoleId) -> DispatchResult { - ensure!(>::contains_key(role_id), Error::::RoleNotFound); - Ok(()) - } - - /// Get `Role` by id from the storage or return `RoleNotFound` error. - pub fn require_role(role_id: RoleId) -> Result, DispatchError> { - Ok(Self::role_by_id(role_id).ok_or(Error::::RoleNotFound)?) - } - - /// Ensure that this account is not blocked and has 'ManageRoles' permission in a given space - pub fn ensure_role_manager(account: T::AccountId, space_id: SpaceId) -> DispatchResult { - ensure!( - T::IsAccountBlocked::is_allowed_account(account.clone(), space_id), - ModerationError::AccountIsBlocked - ); - Self::ensure_user_has_space_permission_with_load_space( - User::Account(account), - space_id, - SpacePermission::ManageRoles, - Error::::NoPermissionToManageRoles.into(), - ) - } - - fn ensure_user_has_space_permission_with_load_space( - user: User, - space_id: SpaceId, - permission: SpacePermission, - error: DispatchError, - ) -> DispatchResult { - let space = T::SpacePermissionsProvider::space_permissions_info(space_id)?; - - let mut is_owner = false; - let mut is_follower = false; - - match &user { - User::Account(account) => { - is_owner = *account == space.owner; - - // No need to check if a user is follower, if they already are an owner: - is_follower = - is_owner || T::SpaceFollows::is_space_follower(account.clone(), space_id); - }, - User::Space(_) => (/* Not implemented yet. */), - } - - Self::ensure_user_has_space_permission( - user, - SpacePermissionsContext { - space_id, - is_space_owner: is_owner, - is_space_follower: is_follower, - space_perms: space.permissions, - }, - permission, - error, - ) - } - - fn ensure_user_has_space_permission( - user: User, - ctx: SpacePermissionsContext, - permission: SpacePermission, - error: DispatchError, - ) -> DispatchResult { - match Permissions::::has_user_a_space_permission(ctx.clone(), permission.clone()) { - Some(true) => return Ok(()), - Some(false) => return Err(error), - _ => (/* Need to check in dynamic roles */), - } - - Self::has_permission_in_space_roles(user, ctx.space_id, permission, error) - } - - fn has_permission_in_space_roles( - user: User, - space_id: SpaceId, - permission: SpacePermission, - error: DispatchError, - ) -> DispatchResult { - let role_ids = Self::role_ids_by_user_in_space(user, space_id); - - for role_id in role_ids { - if let Some(role) = Self::role_by_id(role_id) { - if role.disabled { - continue - } - - let mut is_expired = false; - if let Some(expires_at) = role.expires_at { - if expires_at <= >::block_number() { - is_expired = true; - } - } - - if !is_expired && role.permissions.contains(&permission) { - return Ok(()) - } - } - } - - Err(error) - } -} - -impl Role { - pub fn new( - created_by: T::AccountId, - space_id: SpaceId, - time_to_live: Option, - content: Content, - permissions: BTreeSet, - ) -> Result { - let role_id = Pallet::::next_role_id(); - - let mut expires_at: Option = None; - if let Some(ttl) = time_to_live { - expires_at = Some(ttl + >::block_number()); - } - - let new_role = Role:: { - created: new_who_and_when::(created_by), - id: role_id, - space_id, - disabled: false, - expires_at, - content, - permissions, - }; - - Ok(new_role) - } - - pub fn set_disabled(&mut self, disable: bool) -> DispatchResult { - if self.disabled && disable { - return Err(Error::::RoleAlreadyDisabled.into()) - } else if !self.disabled && !disable { - return Err(Error::::RoleAlreadyEnabled.into()) - } - - self.disabled = disable; - - Ok(()) - } - - pub fn revoke_from_users(&self, users: Vec>) { - let mut users_by_role = >::take(self.id); - - for user in users.iter() { - let role_idx_by_user_opt = Pallet::::role_ids_by_user_in_space(&user, self.space_id) - .iter() - .position(|x| *x == self.id); - - if let Some(role_idx) = role_idx_by_user_opt { - >::mutate(user, self.space_id, |n| n.swap_remove(role_idx)); - } - - let user_idx_by_role_opt = users_by_role.iter().position(|x| x == user); - - if let Some(user_idx) = user_idx_by_role_opt { - users_by_role.swap_remove(user_idx); - } - } - >::insert(self.id, users_by_role); - } -} - -impl PermissionChecker for Pallet { - type AccountId = T::AccountId; - - fn ensure_user_has_space_permission( - user: User, - ctx: SpacePermissionsContext, - permission: SpacePermission, - error: DispatchError, - ) -> DispatchResult { - Self::ensure_user_has_space_permission(user, ctx, permission, error) - } -} diff --git a/pallets/roles/src/lib.rs b/pallets/roles/src/lib.rs deleted file mode 100644 index 60e8276..0000000 --- a/pallets/roles/src/lib.rs +++ /dev/null @@ -1,490 +0,0 @@ -//! # Roles Module -//! -//! This module allow you to create dynalic roles with an associated set of permissions -//! and grant them to users (accounts or space ids) within a given space. -//! -//! For example if you want to create a space that enables editors in a similar way to Medium, -//! you would create a role "Editor" with permissions such as `CreatePosts`, `UpdateAnyPost`, -//! and `HideAnyComment`. Then you would grant this role to the specific accounts you would like -//! to make editors. - -#![cfg_attr(not(feature = "std"), no_std)] - -use codec::{Decode, Encode}; -use frame_support::{dispatch::DispatchResult, ensure, traits::Get}; -use frame_system::{self as system, ensure_signed}; -use scale_info::TypeInfo; -use sp_runtime::RuntimeDebug; -use sp_std::{collections::btree_set::BTreeSet, prelude::*}; - -use pallet_permissions::{ - Pallet as Permissions, PermissionChecker, SpacePermission, SpacePermissionSet, -}; -use subsocial_support::{ - convert_users_vec_to_btree_set, ensure_content_is_valid, new_who_and_when, - traits::{IsAccountBlocked, IsContentBlocked, SpaceFollowsProvider, SpacePermissionsProvider}, - Content, ModerationError, SpaceId, User, WhoAndWhenOf, -}; - -pub use pallet::*; -pub mod functions; - -pub mod types; -pub use types::*; -// pub mod rpc; - -#[cfg(test)] -mod mock; - -#[cfg(feature = "runtime-benchmarks")] -mod benchmarking; -#[cfg(all(test, not(feature = "runtime-benchmarks")))] -mod tests; -pub mod weights; - -#[frame_support::pallet] -pub mod pallet { - use super::*; - use crate::weights::WeightInfo; - use frame_support::pallet_prelude::*; - use frame_system::pallet_prelude::*; - use pallet_permissions::SpacePermissionsInfoOf; - use subsocial_support::{remove_from_vec, WhoAndWhen}; - - #[pallet::config] - pub trait Config: - frame_system::Config + pallet_permissions::Config + pallet_timestamp::Config - { - /// The overarching event type. - type RuntimeEvent: From> + IsType<::RuntimeEvent>; - - /// When deleting a role via `delete_role()` dispatch, this parameter is checked. - /// If the number of users that own a given role is greater or equal to this number, - /// then `TooManyUsersToDeleteRole` error will be returned and the dispatch will fail. - #[pallet::constant] - type MaxUsersToProcessPerDeleteRole: Get; - - type SpacePermissionsProvider: SpacePermissionsProvider< - Self::AccountId, - SpacePermissionsInfoOf, - >; - - type SpaceFollows: SpaceFollowsProvider; - - type IsAccountBlocked: IsAccountBlocked; - - type IsContentBlocked: IsContentBlocked; - - /// Weight information for extrinsics in this pallet. - type WeightInfo: WeightInfo; - } - - #[pallet::pallet] - #[pallet::generate_store(pub(super) trait Store)] - #[pallet::without_storage_info] - pub struct Pallet(_); - - #[pallet::event] - #[pallet::generate_deposit(pub(super) fn deposit_event)] - pub enum Event { - RoleCreated { account: T::AccountId, space_id: SpaceId, role_id: RoleId }, - RoleUpdated { account: T::AccountId, role_id: RoleId }, - RoleDeleted { account: T::AccountId, role_id: RoleId }, - RoleGranted { account: T::AccountId, role_id: RoleId, users: Vec> }, - RoleRevoked { account: T::AccountId, role_id: RoleId, users: Vec> }, - } - - #[pallet::error] - pub enum Error { - /// Role was not found by id. - RoleNotFound, - - /// `NextRoleId` exceeds its maximum value. - RoleIdOverflow, - - /// Account does not have permission to manage roles in this space. - NoPermissionToManageRoles, - - /// Nothing to update in role. - NoUpdatesProvided, - - /// No permissions provided when trying to create a new role. - /// A role must have at least one permission. - NoPermissionsProvided, - - /// No users provided when trying to grant a role. - /// A role must be granted/revoked to/from at least one user. - NoUsersProvided, - - /// Canot remove a role from this many users in a single transaction. - /// See `MaxUsersToProcessPerDeleteRole` parameter of this trait. - TooManyUsersToDeleteRole, - - /// The user count sent doesn't match the real user count. - IncorrectUserCount, - - /// Cannot disable a role that is already disabled. - RoleAlreadyDisabled, - - /// Cannot enable a role that is already enabled. - RoleAlreadyEnabled, - } - - #[pallet::type_value] - pub fn DefaultForNextRoleId() -> RoleId { - FIRST_ROLE_ID - } - - /// The next role id. - #[pallet::storage] - #[pallet::getter(fn next_role_id)] - pub type NextRoleId = StorageValue<_, RoleId, ValueQuery, DefaultForNextRoleId>; - - /// Get the details of a role by its' id. - #[pallet::storage] - #[pallet::getter(fn role_by_id)] - pub type RoleById = StorageMap<_, Twox64Concat, RoleId, Role>; - - /// Get a list of all users (account or space ids) that a given role has been granted to. - #[pallet::storage] - #[pallet::getter(fn users_by_role_id)] - pub type UsersByRoleId = - StorageMap<_, Twox64Concat, RoleId, Vec>, ValueQuery>; - - // TODO: maybe use BoundedVec here? - /// Get a list of all role ids available in a given space. - #[pallet::storage] - #[pallet::getter(fn role_ids_by_space_id)] - pub type RoleIdsBySpaceId = - StorageMap<_, Twox64Concat, SpaceId, Vec, ValueQuery>; - - /// Get a list of all role ids owned by a given user (account or space id) - /// within a given space. - #[pallet::storage] - #[pallet::getter(fn role_ids_by_user_in_space)] - pub type RoleIdsByUserInSpace = StorageDoubleMap< - _, - Blake2_128Concat, - User, - Twox64Concat, - SpaceId, - Vec, - ValueQuery, - >; - - #[pallet::call] - impl Pallet { - /// Create a new role, with a list of permissions, within a given space. - /// - /// `content` can optionally contain additional information associated with a role, - /// such as a name, description, and image for a role. This may be useful for end users. - /// - /// Only the space owner or a user with `ManageRoles` permission can call this dispatch. - #[pallet::call_index(0)] - #[pallet::weight(::WeightInfo::create_role())] - pub fn create_role( - origin: OriginFor, - space_id: SpaceId, - time_to_live: Option, - content: Content, - permissions: Vec, - ) -> DispatchResult { - let who = ensure_signed(origin)?; - - ensure!(!permissions.is_empty(), Error::::NoPermissionsProvided); - - ensure_content_is_valid(content.clone())?; - ensure!( - T::IsContentBlocked::is_allowed_content(content.clone(), space_id), - ModerationError::ContentIsBlocked, - ); - - Self::ensure_role_manager(who.clone(), space_id)?; - - let permissions_set = permissions.into_iter().collect(); - let new_role = - Role::::new(who.clone(), space_id, time_to_live, content, permissions_set)?; - - // TODO review strange code: - let next_role_id = new_role.id.checked_add(1).ok_or(Error::::RoleIdOverflow)?; - NextRoleId::::put(next_role_id); - - RoleById::::insert(new_role.id, new_role.clone()); - RoleIdsBySpaceId::::mutate(space_id, |role_ids| role_ids.push(new_role.id)); - - Self::deposit_event(Event::RoleCreated { - account: who, - space_id, - role_id: new_role.id, - }); - Ok(()) - } - - /// Update an existing role by a given id. - /// Only the space owner or a user with `ManageRoles` permission can call this dispatch. - #[pallet::call_index(1)] - #[pallet::weight(::WeightInfo::update_role())] - pub fn update_role( - origin: OriginFor, - role_id: RoleId, - update: RoleUpdate, - ) -> DispatchResult { - let who = ensure_signed(origin)?; - - let has_updates = update.disabled.is_some() || - update.content.is_some() || - update.permissions.is_some(); - - ensure!(has_updates, Error::::NoUpdatesProvided); - - let mut role = Self::require_role(role_id)?; - - Self::ensure_role_manager(who.clone(), role.space_id)?; - - let mut is_update_applied = false; - - if let Some(disabled) = update.disabled { - if disabled != role.disabled { - role.set_disabled(disabled)?; - is_update_applied = true; - } - } - - if let Some(content) = update.content { - if content != role.content { - ensure_content_is_valid(content.clone())?; - ensure!( - T::IsContentBlocked::is_allowed_content(content.clone(), role.space_id), - ModerationError::ContentIsBlocked - ); - - role.content = content; - is_update_applied = true; - } - } - - if let Some(permissions) = update.permissions { - if !permissions.is_empty() { - let permissions_diff: Vec<_> = - permissions.symmetric_difference(&role.permissions).cloned().collect(); - - if !permissions_diff.is_empty() { - role.permissions = permissions; - is_update_applied = true; - } - } - } - - if is_update_applied { - >::insert(role_id, role); - Self::deposit_event(Event::RoleUpdated { account: who, role_id }); - } - Ok(()) - } - - /// Delete a given role and clean all associated storage items. - /// Only the space owner or a user with `ManageRoles` permission can call this dispatch. - #[pallet::call_index(2)] - #[pallet::weight(::WeightInfo::delete_role(*user_count))] - pub fn delete_role( - origin: OriginFor, - role_id: RoleId, - user_count: u32, - ) -> DispatchResult { - let who = ensure_signed(origin)?; - - let role = Self::require_role(role_id)?; - - Self::ensure_role_manager(who.clone(), role.space_id)?; - - let users = Self::users_by_role_id(role_id); - ensure!(users.len() as u32 == user_count, Error::::IncorrectUserCount); - ensure!( - users.len() <= T::MaxUsersToProcessPerDeleteRole::get() as usize, - Error::::TooManyUsersToDeleteRole - ); - - let role_idx_by_space_opt = - Self::role_ids_by_space_id(role.space_id).iter().position(|x| *x == role_id); - - if let Some(role_idx) = role_idx_by_space_opt { - RoleIdsBySpaceId::::mutate(role.space_id, |n| n.swap_remove(role_idx)); - } - - role.revoke_from_users(users); - - >::remove(role_id); - >::remove(role_id); - - Self::deposit_event(Event::RoleDeleted { account: who, role_id }); - Ok(()) - } - - /// Grant a given role to a list of users. - /// Only the space owner or a user with `ManageRoles` permission can call this dispatch. - #[pallet::call_index(3)] - #[pallet::weight(::WeightInfo::grant_role(users.len() as u32))] - pub fn grant_role( - origin: OriginFor, - role_id: RoleId, - users: Vec>, - ) -> DispatchResult { - let who = ensure_signed(origin)?; - - ensure!(!users.is_empty(), Error::::NoUsersProvided); - let users_set: BTreeSet> = convert_users_vec_to_btree_set(users)?; - - let role = Self::require_role(role_id)?; - - Self::ensure_role_manager(who.clone(), role.space_id)?; - - for user in users_set.iter() { - if !Self::users_by_role_id(role_id).contains(user) { - >::mutate(role_id, |users| { - users.push(user.clone()); - }); - } - if !Self::role_ids_by_user_in_space(user.clone(), role.space_id).contains(&role_id) - { - >::mutate(user.clone(), role.space_id, |roles| { - roles.push(role_id); - }) - } - } - - Self::deposit_event(Event::RoleGranted { - account: who, - role_id, - users: users_set.iter().cloned().collect(), - }); - Ok(()) - } - - /// Revoke a given role from a list of users. - /// Only the space owner or a user with `ManageRoles` permission can call this dispatch. - #[pallet::call_index(4)] - #[pallet::weight(::WeightInfo::revoke_role(users.len() as u32))] - pub fn revoke_role( - origin: OriginFor, - role_id: RoleId, - users: Vec>, - ) -> DispatchResult { - let who = ensure_signed(origin)?; - - ensure!(!users.is_empty(), Error::::NoUsersProvided); - - let role = Self::require_role(role_id)?; - - Self::ensure_role_manager(who.clone(), role.space_id)?; - - role.revoke_from_users(users.clone()); - - Self::deposit_event(Event::RoleRevoked { account: who, role_id, users }); - Ok(()) - } - - #[pallet::call_index(5)] - #[pallet::weight(( - Weight::from_ref_time(25_000) + T::DbWeight::get().reads_writes(1, 2), - DispatchClass::Operational, - Pays::Yes, - ))] - pub fn force_create_role( - origin: OriginFor, - created: WhoAndWhenOf, - role_id: RoleId, - space_id: SpaceId, - disabled: bool, - content: Content, - permissions: SpacePermissionSet, - ) -> DispatchResultWithPostInfo { - ensure_root(origin)?; - - let WhoAndWhen { account, time, .. } = created; - let new_who_and_when = WhoAndWhen { - account: account.clone(), - block: frame_system::Pallet::::block_number(), - time, - }; - - let new_role = Role:: { - created: new_who_and_when, - id: role_id, - space_id, - disabled, - expires_at: None, - content, - permissions, - }; - - if let Ok(role) = Self::require_role(role_id) { - if role.space_id != space_id { - RoleIdsBySpaceId::::mutate(role.space_id, |role_ids| { - remove_from_vec(role_ids, role_id) - }); - } - } - - RoleById::::insert(role_id, new_role); - RoleIdsBySpaceId::::mutate(space_id, |role_ids| role_ids.push(role_id)); - - Self::deposit_event(Event::RoleCreated { account, space_id, role_id }); - - Ok(Pays::No.into()) - } - - #[pallet::call_index(6)] - #[pallet::weight(( - Weight::from_ref_time(10_000) + T::DbWeight::get().writes(1), - DispatchClass::Operational, - Pays::Yes, - ))] - pub fn force_grant_role( - origin: OriginFor, - role_id: RoleId, - users: Vec>, - ) -> DispatchResultWithPostInfo { - ensure_root(origin)?; - - let space_id = Self::require_role(role_id)?.space_id; - let space = T::SpacePermissionsProvider::space_permissions_info(space_id)?; - - let users_set: BTreeSet> = convert_users_vec_to_btree_set(users)?; - - for user in users_set.iter() { - if !Self::users_by_role_id(role_id).contains(user) { - >::mutate(role_id, |users| { - users.push(user.clone()); - }); - } - if !Self::role_ids_by_user_in_space(user.clone(), space_id).contains(&role_id) { - >::mutate(user.clone(), space_id, |roles| { - roles.push(role_id); - }) - } - } - - Self::deposit_event(Event::RoleGranted { - account: space.owner, - role_id, - users: users_set.iter().cloned().collect(), - }); - Ok(Pays::No.into()) - } - - #[pallet::call_index(7)] - #[pallet::weight(( - Weight::from_ref_time(10_000) + T::DbWeight::get().writes(1), - DispatchClass::Operational, - Pays::Yes, - ))] - pub fn force_set_next_role_id( - origin: OriginFor, - role_id: RoleId, - ) -> DispatchResultWithPostInfo { - ensure_root(origin)?; - NextRoleId::::put(role_id); - Ok(Pays::No.into()) - } - } -} diff --git a/pallets/roles/src/mock.rs b/pallets/roles/src/mock.rs deleted file mode 100644 index 7d00783..0000000 --- a/pallets/roles/src/mock.rs +++ /dev/null @@ -1,345 +0,0 @@ -use super::*; - -use sp_core::H256; -use sp_io::TestExternalities; -use sp_std::{collections::btree_set::BTreeSet, prelude::Vec}; - -use frame_support::{ - assert_ok, - dispatch::{DispatchError, DispatchResult}, - parameter_types, - traits::{ConstU32, Everything}, -}; -use sp_runtime::{ - testing::Header, - traits::{BlakeTwo256, IdentityLookup}, -}; - -use pallet_permissions::{SpacePermission, SpacePermission as SP, SpacePermissions}; -use subsocial_support::{ - traits::{SpaceFollowsProvider, SpacePermissionsProvider as SpacePermissionsProviderT}, - Content, SpaceId, SpacePermissionsInfo, User, -}; - -use crate as roles; - -type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; -type Block = frame_system::mocking::MockBlock; - -frame_support::construct_runtime!( - pub enum Test where - Block = Block, - NodeBlock = Block, - UncheckedExtrinsic = UncheckedExtrinsic, - { - System: system::{Pallet, Call, Config, Storage, Event}, - Balances: pallet_balances::{Pallet, Call, Storage, Config, Event}, - Timestamp: pallet_timestamp::{Pallet, Call, Storage, Inherent}, - Roles: roles::{Pallet, Call, Storage, Event}, - Spaces: pallet_spaces::{Pallet, Call, Storage, Event}, - } -); - -pub(super) type AccountId = u64; -pub(super) type Balance = u64; -type BlockNumber = u64; - -parameter_types! { - pub const BlockHashCount: u64 = 250; - pub const SS58Prefix: u8 = 42; -} - -impl frame_system::Config for Test { - type BaseCallFilter = Everything; - type BlockWeights = (); - type BlockLength = (); - type RuntimeOrigin = RuntimeOrigin; - type RuntimeCall = RuntimeCall; - type Index = u64; - type BlockNumber = BlockNumber; - type Hash = H256; - type Hashing = BlakeTwo256; - type AccountId = AccountId; - type Lookup = IdentityLookup; - type Header = Header; - type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; - type DbWeight = (); - type Version = (); - type PalletInfo = PalletInfo; - type AccountData = pallet_balances::AccountData; - type OnNewAccount = (); - type OnKilledAccount = (); - type SystemWeightInfo = (); - type SS58Prefix = SS58Prefix; - type OnSetCode = (); - type MaxConsumers = frame_support::traits::ConstU32<16>; -} - -parameter_types! { - pub const MinimumPeriod: u64 = 5; -} - -impl pallet_timestamp::Config for Test { - type Moment = u64; - type OnTimestampSet = (); - type MinimumPeriod = MinimumPeriod; - type WeightInfo = (); -} - -parameter_types! { - pub const ExistentialDeposit: u64 = 1; -} - -impl pallet_balances::Config for Test { - type Balance = u64; - type DustRemoval = (); - type RuntimeEvent = RuntimeEvent; - type ExistentialDeposit = ExistentialDeposit; - type AccountStore = System; - type WeightInfo = (); - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = (); -} - -use pallet_permissions::default_permissions::DefaultSpacePermissions; - -impl pallet_permissions::Config for Test { - type DefaultSpacePermissions = DefaultSpacePermissions; -} - -parameter_types! { - pub const MaxUsersToProcessPerDeleteRole: u16 = 20; -} - -impl Config for Test { - type RuntimeEvent = RuntimeEvent; - type MaxUsersToProcessPerDeleteRole = MaxUsersToProcessPerDeleteRole; - #[cfg(feature = "runtime-benchmarks")] - type SpacePermissionsProvider = Spaces; - #[cfg(not(feature = "runtime-benchmarks"))] - type SpacePermissionsProvider = Self; - type SpaceFollows = Roles; - type IsAccountBlocked = (); - type IsContentBlocked = (); - type WeightInfo = (); -} - -impl pallet_spaces::Config for Test { - type RuntimeEvent = RuntimeEvent; - type Roles = Roles; - type SpaceFollows = Roles; - type IsAccountBlocked = (); - type IsContentBlocked = (); - type MaxSpacesPerAccount = ConstU32<100>; - type WeightInfo = (); -} - -impl SpacePermissionsProviderT> - for Test -{ - // This function should return an error every time Space doesn't exist by SpaceId - // Currently, we have a list of valid space id's to check - fn space_permissions_info( - id: SpaceId, - ) -> Result, DispatchError> { - if valid_space_ids().contains(&id) { - return Ok(SpacePermissionsInfo { owner: ACCOUNT1, permissions: None }) - } - - Err("mock:SpaceNotFound".into()) - } - - fn ensure_space_owner(id: SpaceId, account: &AccountId) -> DispatchResult { - if valid_space_ids().contains(&id) { - if *account == ACCOUNT1 { - return Ok(()) - } - } - - Err("mock:NotSpaceOwner".into()) - } -} - -impl SpaceFollowsProvider for Pallet { - type AccountId = AccountId; - - fn is_space_follower(_account: Self::AccountId, _space_id: u64) -> bool { - true - } -} - -pub struct ExtBuilder; - -impl ExtBuilder { - pub fn build() -> TestExternalities { - let storage = system::GenesisConfig::default().build_storage::().unwrap(); - - let mut ext = TestExternalities::from(storage); - ext.execute_with(|| System::set_block_number(1)); - - ext - } - - pub fn build_with_a_few_roles_granted_to_account2() -> TestExternalities { - let storage = system::GenesisConfig::default().build_storage::().unwrap(); - - let mut ext = TestExternalities::from(storage); - ext.execute_with(|| { - System::set_block_number(1); - let user = User::Account(ACCOUNT2); - - assert_ok!(_create_role(None, None, None, None, Some(self::permission_set_random()))); // RoleId 1 - assert_ok!(_create_default_role()); // RoleId 2 - - assert_ok!(_grant_role(None, Some(ROLE1), Some(vec![user.clone()]))); - assert_ok!(_grant_role(None, Some(ROLE2), Some(vec![user]))); - }); - - ext - } -} - -pub(crate) const ACCOUNT1: AccountId = 1; -pub(crate) const ACCOUNT2: AccountId = 2; -pub(crate) const ACCOUNT3: AccountId = 3; - -pub(crate) const ROLE1: RoleId = 1; -pub(crate) const ROLE2: RoleId = 2; -pub(crate) const ROLE3: RoleId = 3; -pub(crate) const ROLE4: RoleId = 4; - -pub(crate) const SPACE1: SpaceId = 1; -pub(crate) const SPACE2: SpaceId = 2; - -pub(crate) fn default_role_content_ipfs() -> Content { - Content::IPFS(b"QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD4".to_vec()) -} - -pub(crate) fn updated_role_content_ipfs() -> Content { - Content::IPFS(b"QmZENA8YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDaazhR8".to_vec()) -} - -pub(crate) fn invalid_role_content_ipfs() -> Content { - Content::IPFS(b"QmRAQB6DaazhR8".to_vec()) -} - -/// Permissions Set that includes next permission: ManageRoles -pub(crate) fn permission_set_default() -> Vec { - vec![SP::ManageRoles] -} - -/// Permissions Set that includes next permissions: ManageRoles, CreatePosts -pub(crate) fn permission_set_updated() -> Vec { - vec![SP::ManageRoles, SP::CreatePosts] -} - -/// Permissions Set that includes random permissions -pub(crate) fn permission_set_random() -> Vec { - vec![SP::CreatePosts, SP::UpdateOwnPosts, SP::UpdateAnyPost, SP::UpdateEntityStatus] -} - -pub(crate) fn valid_space_ids() -> Vec { - vec![SPACE1] -} - -/// Permissions Set that includes nothing -pub(crate) fn permission_set_empty() -> Vec { - vec![] -} - -pub(crate) fn role_update( - disabled: Option, - content: Option, - permissions: Option>, -) -> RoleUpdate { - RoleUpdate { disabled, content, permissions } -} - -pub(crate) fn _create_default_role() -> DispatchResult { - _create_role(None, None, None, None, None) -} - -pub(crate) fn _create_role( - origin: Option, - space_id: Option, - time_to_live: Option>, - content: Option, - permissions: Option>, -) -> DispatchResult { - Roles::create_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - space_id.unwrap_or(SPACE1), - time_to_live.unwrap_or_default(), // Should return 'None' - content.unwrap_or_else(self::default_role_content_ipfs), - permissions.unwrap_or_else(self::permission_set_default), - ) -} - -pub(crate) fn _update_default_role() -> DispatchResult { - _update_role(None, None, None) -} - -pub(crate) fn _update_role( - origin: Option, - role_id: Option, - update: Option, -) -> DispatchResult { - Roles::update_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - role_id.unwrap_or(ROLE1), - update.unwrap_or_else(|| { - self::role_update( - Some(true), - Some(self::updated_role_content_ipfs()), - Some(self::permission_set_updated().into_iter().collect()), - ) - }), - ) -} - -pub(crate) fn _grant_default_role() -> DispatchResult { - _grant_role(None, None, None) -} - -pub(crate) fn _grant_role( - origin: Option, - role_id: Option, - users: Option>>, -) -> DispatchResult { - Roles::grant_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - role_id.unwrap_or(ROLE1), - users.unwrap_or_else(|| vec![User::Account(ACCOUNT2)]), - ) -} - -pub(crate) fn _revoke_default_role() -> DispatchResult { - _revoke_role(None, None, None) -} - -pub(crate) fn _revoke_role( - origin: Option, - role_id: Option, - users: Option>>, -) -> DispatchResult { - Roles::revoke_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - role_id.unwrap_or(ROLE1), - users.unwrap_or_else(|| vec![User::Account(ACCOUNT2)]), - ) -} - -pub(crate) fn _delete_default_role() -> DispatchResult { - _delete_role(None, None) -} - -pub(crate) fn _delete_role(origin: Option, role_id: Option) -> DispatchResult { - let role_id = role_id.unwrap_or(ROLE1); - Roles::delete_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - role_id, - UsersByRoleId::::get(role_id).len() as u32, - ) -} diff --git a/pallets/roles/src/rpc.rs b/pallets/roles/src/rpc.rs deleted file mode 100644 index 300738c..0000000 --- a/pallets/roles/src/rpc.rs +++ /dev/null @@ -1,47 +0,0 @@ -use crate::{Config, Pallet, Role, RoleIdsByUserInSpace}; - -use frame_support::storage::IterableStorageDoubleMap; -use sp_std::prelude::*; -use sp_std::collections::{ btree_set::BTreeSet }; - -use pallet_utils::{SpaceId, User}; -use pallet_permissions::{SpacePermission}; - -impl Pallet { - pub fn get_space_permissions_by_account( - account: T::AccountId, - space_id: SpaceId - ) -> Vec { - - Self::role_ids_by_user_in_space(User::Account(account), space_id) - .iter() - .filter_map(Self::role_by_id) - .flat_map(|role: Role| role.permissions.into_iter()) - .collect::>() - .iter().cloned().collect() - } - - pub fn get_accounts_with_any_role_in_space(space_id: SpaceId) -> Vec { - - Self::role_ids_by_space_id(space_id) - .iter() - .flat_map(Self::users_by_role_id) - .filter_map(|user| user.maybe_account()) - .collect::>() - .iter().cloned().collect() - } - - pub fn get_space_ids_for_account_with_any_role(account_id: T::AccountId) -> Vec { - let user = &User::Account(account_id); - let mut space_ids = Vec::new(); - - RoleIdsByUserInSpace::::iter_prefix(user) - .for_each(|(space_id, role_ids)| { - if !role_ids.is_empty() { - space_ids.push(space_id); - } - }); - - space_ids - } -} \ No newline at end of file diff --git a/pallets/roles/src/tests.rs b/pallets/roles/src/tests.rs deleted file mode 100644 index d4861be..0000000 --- a/pallets/roles/src/tests.rs +++ /dev/null @@ -1,567 +0,0 @@ -use crate::{mock::*, *}; - -use frame_support::{assert_noop, assert_ok}; -use subsocial_support::ContentError; - -#[test] -fn create_role_should_work() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - - // Check whether Role is stored correctly - assert!(Roles::role_by_id(ROLE1).is_some()); - - // Check whether data in Role structure is correct - let role = Roles::role_by_id(ROLE1).unwrap(); - assert_eq!(Roles::next_role_id(), ROLE2); - - assert_eq!(role.space_id, SPACE1); - assert_eq!(role.disabled, false); - assert_eq!(role.content, self::default_role_content_ipfs()); - assert_eq!(role.permissions, self::permission_set_default().into_iter().collect()); - }); -} - -#[test] -fn create_role_should_work_with_a_few_roles() { - ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { - assert_ok!(_create_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // On SpaceId 1 - None, // Without time_to_live - None, // With default content - Some(self::permission_set_updated()) - )); // RoleId 3 - - // Check whether Role is stored correctly - assert!(Roles::role_by_id(ROLE3).is_some()); - - // Check whether data in Role structure is correct - let role = Roles::role_by_id(ROLE3).unwrap(); - assert_eq!(Roles::next_role_id(), ROLE4); - - assert_eq!(role.space_id, SPACE1); - assert_eq!(role.disabled, false); - assert_eq!(role.content, self::default_role_content_ipfs()); - assert_eq!(role.permissions, self::permission_set_updated().into_iter().collect()); - }); -} - -#[test] -fn create_role_should_fail_with_space_not_found() { - ExtBuilder::build().execute_with(|| { - assert_noop!( - _create_role( - None, // From ACCOUNT1 - Some(SPACE2), - None, // Without time_to_live - None, // With default content - None // With default permission set - ), - "mock:SpaceNotFound" - ); - }); -} - -#[test] -fn create_role_should_fail_with_no_permission() { - ExtBuilder::build().execute_with(|| { - assert_noop!( - _create_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // On SpaceId 1 - None, // Without time_to_live - None, // With default content - None // With default permission set - ), - Error::::NoPermissionToManageRoles - ); - }); -} - -#[test] -fn create_role_should_fail_with_no_permissions_provided() { - ExtBuilder::build().execute_with(|| { - assert_noop!( - _create_role( - None, // From ACCOUNT1 - None, // On SpaceId 1 - None, // Without time_to_live - None, // With default permission set - Some(self::permission_set_empty()) - ), - Error::::NoPermissionsProvided - ); - }); -} - -#[test] -fn create_role_should_fail_with_ipfs_is_incorrect() { - ExtBuilder::build().execute_with(|| { - assert_noop!( - _create_role( - None, // From ACCOUNT1 - None, // On SpaceId 1 - None, // Without time_to_live - Some(self::invalid_role_content_ipfs()), - None // With default permissions set - ), - ContentError::InvalidIpfsCid - ); - }); -} - -#[test] -fn create_role_should_fail_with_a_few_roles_no_permission() { - ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { - assert_ok!(_delete_role(None, Some(ROLE2))); - assert_noop!( - _create_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // On SpaceId 1 - None, // Without time_to_live - None, // With default content - Some(self::permission_set_random()) - ), - Error::::NoPermissionToManageRoles - ); - }); -} - -#[test] -fn update_role_should_work() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_ok!(_update_default_role()); - - // Check whether Role is stored correctly - assert!(Roles::role_by_id(ROLE1).is_some()); - - // Check whether data in Role structure is correct - let role = Roles::role_by_id(ROLE1).unwrap(); - - assert_eq!(role.space_id, SPACE1); - assert_eq!(role.disabled, true); - assert_eq!(role.content, self::updated_role_content_ipfs()); - assert_eq!(role.permissions, self::permission_set_updated().into_iter().collect()); - }); -} - -#[test] -fn update_role_should_work_with_empty_perms_provided_no_changes() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_ok!(_update_role( - None, // From ACCOUNT1 - None, // On RoleId 1 - Some(self::role_update( - Some(true), - None, - Some(self::permission_set_empty().into_iter().collect()) - )) - )); - - // Check whether data in Role structure is correct - let role = Roles::role_by_id(ROLE1).unwrap(); - - assert_eq!(role.space_id, SPACE1); - assert_eq!(role.disabled, true); - assert_eq!(role.content, self::default_role_content_ipfs()); - assert_eq!(role.permissions, self::permission_set_default().into_iter().collect()); - }); -} - -#[test] -fn update_role_should_work_with_same_perms_provided_no_update() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_ok!( - _update_role( - None, // From ACCOUNT1 - None, // On RoleId 1 - Some( - self::role_update( - None, // No changes for disabled - None, // No content changes - Some(self::permission_set_default().into_iter().collect()) // The same permissions_set (no changes should apply) - ) - ) - ) - ); - - // Check whether data in Role structure is correct - let role = Roles::role_by_id(ROLE1).unwrap(); - - assert_eq!( - role.permissions, - self::permission_set_default().into_iter().collect() - ); - }); -} - -#[test] -fn update_role_should_work_with_a_few_roles() { - ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { - assert_ok!(_update_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - Some(ROLE1), - Some(self::role_update( - None, - None, - Some(self::permission_set_updated().into_iter().collect()) - )) - )); - - // Check whether Role is stored correctly - assert!(Roles::role_by_id(ROLE1).is_some()); - - // Check whether data in Role structure is correct - let role = Roles::role_by_id(ROLE1).unwrap(); - - assert_eq!(role.space_id, SPACE1); - assert_eq!(role.disabled, false); - assert_eq!(role.content, self::default_role_content_ipfs()); - assert_eq!(role.permissions, self::permission_set_updated().into_iter().collect()); - }); -} - -#[test] -fn update_role_should_work_not_updated_all_the_same() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_ok!(_update_role( - None, // From ACCOUNT1 - None, // On RoleId 1 - Some(self::role_update( - Some(false), - Some(self::default_role_content_ipfs()), - Some(self::permission_set_default().into_iter().collect()) - )) - )); - - // Check whether Role is stored correctly - assert!(Roles::role_by_id(ROLE1).is_some()); - - // Check whether data in Role structure is correct - let role = Roles::role_by_id(ROLE1).unwrap(); - - assert_eq!(role.space_id, SPACE1); - assert_eq!(role.disabled, false); - assert_eq!(role.content, self::default_role_content_ipfs()); - assert_eq!(role.permissions, self::permission_set_default().into_iter().collect()); - }); -} - -#[test] -fn update_role_should_fail_with_role_not_found() { - ExtBuilder::build().execute_with(|| { - assert_noop!(_update_default_role(), Error::::RoleNotFound); - }); -} - -#[test] -fn update_role_should_fail_with_no_permission() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_noop!( - _update_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // On RoleId 1 - None // With RoleUpdate that updates every mutable (updatable) field - ), - Error::::NoPermissionToManageRoles - ); - }); -} - -#[test] -fn update_role_should_fail_with_no_role_updates() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_noop!( - _update_role( - None, // From ACCOUNT1 - None, // On RoleId 1 - Some(self::role_update(None, None, None)) - ), - Error::::NoUpdatesProvided - ); - }); -} - -#[test] -fn update_role_should_fail_with_ipfs_is_incorrect() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_noop!( - _update_role( - None, // From ACCOUNT1 - None, // On RoleId 1 - Some(self::role_update(None, Some(self::invalid_role_content_ipfs()), None)) - ), - ContentError::InvalidIpfsCid - ); - }); -} - -#[test] -fn update_role_should_fail_with_a_few_roles_no_permission() { - ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { - assert_ok!(_delete_role(None, Some(ROLE2))); - assert_noop!( - _update_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // On RoleId 1 - Some(self::role_update( - None, - None, - Some(self::permission_set_default().into_iter().collect()) - )) - ), - Error::::NoPermissionToManageRoles - ); - }); -} - -#[test] -fn grant_role_should_work() { - ExtBuilder::build().execute_with(|| { - let user = User::Account(ACCOUNT2); - - assert_ok!(_create_default_role()); // RoleId 1 - assert_ok!(_grant_default_role()); // Grant RoleId 1 to ACCOUNT2 - - // Change whether data was stored correctly - assert_eq!(Roles::users_by_role_id(ROLE1), vec![user.clone()]); - assert_eq!(Roles::role_ids_by_user_in_space(user, SPACE1), vec![ROLE1]); - }); -} - -#[test] -fn grant_role_should_work_with_a_few_roles() { - ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { - let user = User::Account(ACCOUNT3); - assert_ok!(_grant_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // RoleId 1 - Some(vec![User::Account(ACCOUNT3)]) - )); - - // Check whether data is stored correctly - assert_eq!( - Roles::users_by_role_id(ROLE1), - vec![User::Account(ACCOUNT2), User::Account(ACCOUNT3)] - ); - assert_eq!(Roles::role_ids_by_user_in_space(user, SPACE1), vec![ROLE1]); - }); -} - -#[test] -fn grant_role_should_fail_with_role_not_found() { - ExtBuilder::build().execute_with(|| { - assert_noop!(_grant_default_role(), Error::::RoleNotFound); - }); -} - -#[test] -fn grant_role_should_fail_with_no_permission() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_noop!( - _grant_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // RoleId 1 - Some(vec![User::Account(ACCOUNT3)]) - ), - Error::::NoPermissionToManageRoles - ); - }); -} - -#[test] -fn grant_role_should_fail_with_no_users_provided() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_noop!( - _grant_role( - None, // From ACCOUNT1 - None, // RoleId 1 - Some(vec![]) - ), - Error::::NoUsersProvided - ); - }); -} - -#[test] -fn grant_role_should_fail_with_a_few_roles_no_permission() { - ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { - assert_ok!(_delete_role(None, Some(ROLE2))); - assert_noop!( - _grant_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // RoleId 1 - Some(vec![User::Account(ACCOUNT3)]) - ), - Error::::NoPermissionToManageRoles - ); - }); -} - -#[test] -fn revoke_role_should_work() { - ExtBuilder::build().execute_with(|| { - let user = User::Account(ACCOUNT2); - - assert_ok!(_create_default_role()); // RoleId 1 - assert_ok!(_grant_default_role()); // Grant RoleId 1 to ACCOUNT2 - assert_ok!(_revoke_default_role()); // Revoke RoleId 1 from ACCOUNT2 - - // Change whether data was stored correctly - assert!(Roles::users_by_role_id(ROLE1).is_empty()); - assert!(Roles::role_ids_by_user_in_space(user, SPACE1).is_empty()); - }); -} - -#[test] -fn revoke_role_should_work_with_a_few_roles() { - ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { - let user = User::Account(ACCOUNT3); - assert_ok!(_revoke_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // RoleId 1 - Some(vec![User::Account(ACCOUNT2)]) - )); - - // Check whether data is stored correctly - assert!(Roles::users_by_role_id(ROLE1).is_empty()); - assert!(Roles::role_ids_by_user_in_space(user, SPACE1).is_empty()); - }); -} - -#[test] -fn revoke_role_should_fail_with_role_not_found() { - ExtBuilder::build().execute_with(|| { - assert_noop!(_revoke_default_role(), Error::::RoleNotFound); - }); -} - -#[test] -fn revoke_role_should_fail_with_no_users_provided() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_noop!(_revoke_role(None, None, Some(vec![])), Error::::NoUsersProvided); - }); -} - -#[test] -fn revoke_role_should_fail_with_no_permission() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_noop!( - _revoke_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // RoleId 1 - Some(vec![User::Account(ACCOUNT3)]) - ), - Error::::NoPermissionToManageRoles - ); - }); -} - -#[test] -fn revoke_role_should_fail_with_a_few_roles_no_permission() { - ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { - assert_ok!(_delete_role(None, Some(ROLE2))); - assert_noop!( - _revoke_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, // RoleId 1 - Some(vec![User::Account(ACCOUNT3)]) - ), - Error::::NoPermissionToManageRoles - ); - }); -} - -#[test] -fn delete_role_should_work() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_ok!(_grant_default_role()); - assert_ok!(_delete_default_role()); - - // Check whether storages are cleaned up - assert!(Roles::role_by_id(ROLE1).is_none()); - assert!(Roles::users_by_role_id(ROLE1).is_empty()); - assert!(Roles::role_ids_by_space_id(SPACE1).is_empty()); - assert!(Roles::role_ids_by_user_in_space(User::Account(ACCOUNT2), SPACE1).is_empty()); - assert_eq!(Roles::next_role_id(), ROLE2); - }); -} - -#[test] -fn delete_role_should_work_with_a_few_roles() { - ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { - assert_ok!(_delete_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None // RoleId 1 - )); - - // Check whether storages are cleaned up - assert!(Roles::role_by_id(ROLE1).is_none()); - assert!(Roles::users_by_role_id(ROLE1).is_empty()); - assert_eq!(Roles::role_ids_by_space_id(SPACE1), vec![ROLE2]); - assert_eq!(Roles::role_ids_by_user_in_space(User::Account(ACCOUNT2), SPACE1), vec![ROLE2]); - assert_eq!(Roles::next_role_id(), ROLE3); - }); -} - -#[test] -fn delete_role_should_fail_with_role_not_found() { - ExtBuilder::build().execute_with(|| { - assert_noop!(_delete_default_role(), Error::::RoleNotFound); - }); -} - -#[test] -fn delete_role_should_fail_with_no_permission() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_role()); // RoleId 1 - assert_noop!( - _delete_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None // RoleId 1 - ), - Error::::NoPermissionToManageRoles - ); - }); -} - -#[test] -fn delete_role_should_fail_with_too_many_users_for_delete_role() { - ExtBuilder::build().execute_with(|| { - let mut users: Vec> = Vec::new(); - for account in 2..23 { - users.push(User::Account(account)); - } - - assert_ok!(_create_default_role()); // RoleId 1 - assert_ok!(_grant_role(None, None, Some(users))); // Grant RoleId 1 to ACCOUNT2-ACCOUNT20 - assert_noop!(_delete_default_role(), Error::::TooManyUsersToDeleteRole); - }); -} - -#[test] -fn delete_role_should_fail_with_a_few_roles_no_permission() { - ExtBuilder::build_with_a_few_roles_granted_to_account2().execute_with(|| { - assert_ok!(_delete_role(None, Some(ROLE2))); - assert_noop!( - _delete_role( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None // RoleId 1 - ), - Error::::NoPermissionToManageRoles - ); - }); -} diff --git a/pallets/roles/src/types.rs b/pallets/roles/src/types.rs deleted file mode 100644 index e77e3ad..0000000 --- a/pallets/roles/src/types.rs +++ /dev/null @@ -1,43 +0,0 @@ -use super::*; - -pub type RoleId = u64; - -pub const FIRST_ROLE_ID: u64 = 1; - -/// Information about a role's permissions, its' containing space, and its' content. -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -#[scale_info(skip_type_params(T))] -pub struct Role { - pub created: WhoAndWhenOf, - - /// Unique sequential identifier of a role. Examples of role ids: `1`, `2`, `3`, and so on. - pub id: RoleId, - - /// An id of a space that contains this role. - pub space_id: SpaceId, - - /// If `true` then the permissions associated with a given role will have no affect. - /// This is useful if you would like to temporarily disable permissions from a given role, - /// without removing the role from its' owners - pub disabled: bool, - - /// An optional block number at which this role will expire. If `expires_at` is `Some` - /// and the current block is greater or equal to its value, the permissions associated - /// with a given role will have no affect. - pub expires_at: Option, - - /// Content can optionally contain additional information associated with a role, - /// such as a name, description, and image for a role. This may be useful for end users. - pub content: Content, - - /// A set of permisions granted to owners of a particular role which are valid - /// only within the space containing this role - pub permissions: SpacePermissionSet, -} - -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -pub struct RoleUpdate { - pub disabled: Option, - pub content: Option, - pub permissions: Option, -} diff --git a/pallets/roles/src/weights.rs b/pallets/roles/src/weights.rs deleted file mode 100644 index 300b5ac..0000000 --- a/pallets/roles/src/weights.rs +++ /dev/null @@ -1,188 +0,0 @@ - -//! Autogenerated weights for pallet_roles -//! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-02-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! HOSTNAME: `benchmarks-ci`, CPU: `Intel(R) Xeon(R) Platinum 8280 CPU @ 2.70GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 - -// Executed Command: - // ./scripts/../target/release/subsocial-collator - // benchmark - // pallet - // --chain - // dev - // --execution - // wasm - // --wasm-execution - // Compiled - // --pallet - // pallet_roles - // --extrinsic - // * - // --steps - // 50 - // --repeat - // 20 - // --heap-pages - // 4096 - // --output - // pallets/roles/src/weights.rs - // --template - // ./.maintain/weight-template.hbs - -#![cfg_attr(rustfmt, rustfmt_skip)] -#![allow(unused_parens)] -#![allow(unused_imports)] -#![allow(non_snake_case)] - -use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; -use sp_std::marker::PhantomData; - -/// Weight functions needed for pallet_roles. -pub trait WeightInfo { - fn create_role() -> Weight; - fn update_role() -> Weight; - fn delete_role(x: u32, ) -> Weight; - fn grant_role(x: u32, ) -> Weight; - fn revoke_role(x: u32, ) -> Weight; -} - -/// Weights for pallet_roles using the Substrate node and recommended hardware. -pub struct SubstrateWeight(PhantomData); - impl WeightInfo for SubstrateWeight { - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: Roles NextRoleId (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) - // Storage: Roles RoleIdsBySpaceId (r:1 w:1) - // Storage: Roles RoleById (r:0 w:1) - fn create_role() -> Weight { - // Minimum execution time: 52_528 nanoseconds. - Weight::from_ref_time(53_688_000) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(3)) - } - // Storage: Roles RoleById (r:1 w:1) - // Storage: Spaces SpaceById (r:1 w:0) - fn update_role() -> Weight { - // Minimum execution time: 48_647 nanoseconds. - Weight::from_ref_time(50_219_000) - .saturating_add(T::DbWeight::get().reads(2)) - .saturating_add(T::DbWeight::get().writes(1)) - } - // Storage: Roles RoleById (r:1 w:1) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: Roles UsersByRoleId (r:1 w:1) - // Storage: Roles RoleIdsBySpaceId (r:1 w:1) - // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) - /// The range of component `x` is `[0, 40]`. - fn delete_role(x: u32, ) -> Weight { - // Minimum execution time: 57_007 nanoseconds. - Weight::from_ref_time(64_783_236) - // Standard Error: 26_706 - .saturating_add(Weight::from_ref_time(8_701_651).saturating_mul(x.into())) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(x.into()))) - .saturating_add(T::DbWeight::get().writes(3)) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(x.into()))) - } - // Storage: Roles RoleById (r:1 w:0) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: Roles UsersByRoleId (r:1 w:1) - // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) - /// The range of component `x` is `[1, 500]`. - fn grant_role(x: u32, ) -> Weight { - // Minimum execution time: 56_274 nanoseconds. - Weight::from_ref_time(56_612_000) - // Standard Error: 131_120 - .saturating_add(Weight::from_ref_time(21_272_680).saturating_mul(x.into())) - .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(x.into()))) - .saturating_add(T::DbWeight::get().writes(1)) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(x.into()))) - } - // Storage: Roles RoleById (r:1 w:0) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: Roles UsersByRoleId (r:1 w:1) - // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) - /// The range of component `x` is `[1, 500]`. - fn revoke_role(x: u32, ) -> Weight { - // Minimum execution time: 61_065 nanoseconds. - Weight::from_ref_time(61_492_000) - // Standard Error: 13_040 - .saturating_add(Weight::from_ref_time(9_647_540).saturating_mul(x.into())) - .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().reads((1_u64).saturating_mul(x.into()))) - .saturating_add(T::DbWeight::get().writes(1)) - .saturating_add(T::DbWeight::get().writes((1_u64).saturating_mul(x.into()))) - } - } - - // For backwards compatibility and tests - impl WeightInfo for () { - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: Roles NextRoleId (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) - // Storage: Roles RoleIdsBySpaceId (r:1 w:1) - // Storage: Roles RoleById (r:0 w:1) - fn create_role() -> Weight { - // Minimum execution time: 52_528 nanoseconds. - Weight::from_ref_time(53_688_000) - .saturating_add(RocksDbWeight::get().reads(4)) - .saturating_add(RocksDbWeight::get().writes(3)) - } - // Storage: Roles RoleById (r:1 w:1) - // Storage: Spaces SpaceById (r:1 w:0) - fn update_role() -> Weight { - // Minimum execution time: 48_647 nanoseconds. - Weight::from_ref_time(50_219_000) - .saturating_add(RocksDbWeight::get().reads(2)) - .saturating_add(RocksDbWeight::get().writes(1)) - } - // Storage: Roles RoleById (r:1 w:1) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: Roles UsersByRoleId (r:1 w:1) - // Storage: Roles RoleIdsBySpaceId (r:1 w:1) - // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) - /// The range of component `x` is `[0, 40]`. - fn delete_role(x: u32, ) -> Weight { - // Minimum execution time: 57_007 nanoseconds. - Weight::from_ref_time(64_783_236) - // Standard Error: 26_706 - .saturating_add(Weight::from_ref_time(8_701_651).saturating_mul(x.into())) - .saturating_add(RocksDbWeight::get().reads(4)) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(x.into()))) - .saturating_add(RocksDbWeight::get().writes(3)) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(x.into()))) - } - // Storage: Roles RoleById (r:1 w:0) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: Roles UsersByRoleId (r:1 w:1) - // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) - /// The range of component `x` is `[1, 500]`. - fn grant_role(x: u32, ) -> Weight { - // Minimum execution time: 56_274 nanoseconds. - Weight::from_ref_time(56_612_000) - // Standard Error: 131_120 - .saturating_add(Weight::from_ref_time(21_272_680).saturating_mul(x.into())) - .saturating_add(RocksDbWeight::get().reads(3)) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(x.into()))) - .saturating_add(RocksDbWeight::get().writes(1)) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(x.into()))) - } - // Storage: Roles RoleById (r:1 w:0) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: Roles UsersByRoleId (r:1 w:1) - // Storage: Roles RoleIdsByUserInSpace (r:1 w:1) - /// The range of component `x` is `[1, 500]`. - fn revoke_role(x: u32, ) -> Weight { - // Minimum execution time: 61_065 nanoseconds. - Weight::from_ref_time(61_492_000) - // Standard Error: 13_040 - .saturating_add(Weight::from_ref_time(9_647_540).saturating_mul(x.into())) - .saturating_add(RocksDbWeight::get().reads(3)) - .saturating_add(RocksDbWeight::get().reads((1_u64).saturating_mul(x.into()))) - .saturating_add(RocksDbWeight::get().writes(1)) - .saturating_add(RocksDbWeight::get().writes((1_u64).saturating_mul(x.into()))) - } - } diff --git a/pallets/space-follows/Cargo.toml b/pallets/space-follows/Cargo.toml deleted file mode 100644 index 5079cef..0000000 --- a/pallets/space-follows/Cargo.toml +++ /dev/null @@ -1,40 +0,0 @@ -[package] -name = 'pallet-space-follows' -version = '0.1.7' -authors = ['DappForce '] -edition = '2021' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Pallet that allows to follow/unfollow spaces' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[features] -default = ['std'] -runtime-benchmarks = ["frame-benchmarking/runtime-benchmarks"] -std = [ - 'codec/std', - 'scale-info/std', - 'frame-benchmarking/std', - 'frame-support/std', - 'frame-system/std', - 'sp-std/std', - 'pallet-spaces/std', - 'subsocial-support/std', -] -try-runtime = ["frame-support/try-runtime"] - -[dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } - -# Local depenpdencies -pallet-spaces = { default-features = false, path = '../spaces' } -subsocial-support = { default-features = false, path = '../support' } - -# Substrate dependencies -frame-benchmarking = { optional = true, git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } -frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } diff --git a/pallets/space-follows/rpc/Cargo.toml b/pallets/space-follows/rpc/Cargo.toml deleted file mode 100644 index f943590..0000000 --- a/pallets/space-follows/rpc/Cargo.toml +++ /dev/null @@ -1,49 +0,0 @@ -[package] -name = 'space-follows-rpc' -version = '0.7.3' -authors = ['DappForce '] -edition = '2018' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'RPC methods for the space-follows pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[dependencies.serde] -optional = true -features = ['derive'] -version = '1.0.119' - -[dependencies.codec] -default-features = false -features = ['derive'] -package = 'parity-scale-codec' -version = '2.0.0' - -[dependencies] -jsonrpc-core = '18.0.0' -jsonrpc-core-client = '18.0.0' -jsonrpc-derive = '18.0.0' - -# Local dependencies -pallet-utils = { default-features = false, path = '../../utils' } - -# Custom Runtime API -space-follows-runtime-api = { default-features = false, path = 'runtime-api' } - -# Substrate dependencies -sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-blockchain = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-rpc = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } - -[features] -default = ['std'] -std = [ - 'serde', - 'sp-runtime/std', - 'sp-api/std', - 'space-follows-runtime-api/std', - 'pallet-utils/std', -] diff --git a/pallets/space-follows/rpc/runtime-api/Cargo.toml b/pallets/space-follows/rpc/runtime-api/Cargo.toml deleted file mode 100644 index 49d3970..0000000 --- a/pallets/space-follows/rpc/runtime-api/Cargo.toml +++ /dev/null @@ -1,41 +0,0 @@ -[package] -name = 'space-follows-runtime-api' -version = '0.7.3' -authors = ['DappForce '] -edition = '2018' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Runtime API definition for the space-follows pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[dependencies.serde] -optional = true -features = ["derive"] -version = "1.0.119" - -[dependencies.codec] -default-features = false -features = ['derive'] -package = 'parity-scale-codec' -version = '2.0.0' - -[dependencies] -# Local dependencies -pallet-utils = { default-features = false, path = '../../../utils' } - -# Substrate dependencies -sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } - -[features] -default = ['std'] -std = [ - 'serde', - 'sp-api/std', - 'sp-std/std', - 'sp-runtime/std', - 'pallet-utils/std', -] diff --git a/pallets/space-follows/rpc/runtime-api/src/lib.rs b/pallets/space-follows/rpc/runtime-api/src/lib.rs deleted file mode 100644 index 1ce9870..0000000 --- a/pallets/space-follows/rpc/runtime-api/src/lib.rs +++ /dev/null @@ -1,16 +0,0 @@ -#![cfg_attr(not(feature = "std"), no_std)] - -use codec::Codec; -use sp_std::vec::Vec; - -use pallet_utils::SpaceId; - -sp_api::decl_runtime_apis! { - pub trait SpaceFollowsApi where - AccountId: Codec - { - fn get_space_ids_followed_by_account(account: AccountId) -> Vec; - - fn filter_followed_space_ids(account: AccountId, space_ids: Vec) -> Vec; - } -} diff --git a/pallets/space-follows/rpc/src/lib.rs b/pallets/space-follows/rpc/src/lib.rs deleted file mode 100644 index 8149233..0000000 --- a/pallets/space-follows/rpc/src/lib.rs +++ /dev/null @@ -1,76 +0,0 @@ -use std::sync::Arc; -use codec::Codec; -use sp_blockchain::HeaderBackend; -use sp_runtime::{generic::BlockId, traits::Block as BlockT}; -use jsonrpc_core::Result; -use jsonrpc_derive::rpc; -use sp_api::ProvideRuntimeApi; - -use pallet_utils::{SpaceId, rpc::map_rpc_error}; -pub use space_follows_runtime_api::SpaceFollowsApi as SpaceFollowsRuntimeApi; - -#[rpc] -pub trait SpaceFollowsApi { - #[rpc(name = "spaceFollows_getSpaceIdsFollowedByAccount")] - fn get_space_ids_followed_by_account( - &self, - at: Option, - account: AccountId, - ) -> Result>; - - #[rpc(name = "spaceFollows_filterFollowedSpaceIds")] - fn filter_followed_space_ids( - &self, - at: Option, - account: AccountId, - space_ids: Vec, - ) -> Result>; -} - -pub struct SpaceFollows { - client: Arc, - _marker: std::marker::PhantomData, -} - -impl SpaceFollows { - pub fn new(client: Arc) -> Self { - Self { - client, - _marker: Default::default(), - } - } -} - -impl SpaceFollowsApi<::Hash, AccountId> - for SpaceFollows -where - Block: BlockT, - AccountId: Codec, - C: Send + Sync + 'static + ProvideRuntimeApi + HeaderBackend, - C::Api: SpaceFollowsRuntimeApi, -{ - fn get_space_ids_followed_by_account( - &self, - at: Option<::Hash>, - account: AccountId, - ) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_space_ids_followed_by_account(&at, account); - runtime_api_result.map_err(map_rpc_error) - } - - fn filter_followed_space_ids( - &self, - at: Option<::Hash>, - account: AccountId, - space_ids: Vec, - ) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.filter_followed_space_ids(&at, account, space_ids); - runtime_api_result.map_err(map_rpc_error) - } -} diff --git a/pallets/space-follows/src/benchmarking.rs b/pallets/space-follows/src/benchmarking.rs deleted file mode 100644 index cb9d664..0000000 --- a/pallets/space-follows/src/benchmarking.rs +++ /dev/null @@ -1,52 +0,0 @@ -//! Space follows pallet benchmarking. - -#![cfg(feature = "runtime-benchmarks")] - -use super::*; -use frame_benchmarking::{account, benchmarks}; -use frame_support::{dispatch::DispatchError, ensure}; -use frame_system::RawOrigin; -use pallet_spaces::types::Space; -use subsocial_support::Content; - -fn create_dummy_space( - origin: RawOrigin, -) -> Result, DispatchError> { - let space_id = pallet_spaces::NextSpaceId::::get(); - - pallet_spaces::Pallet::::create_space(origin.clone().into(), Content::None, None)?; - - let space = pallet_spaces::SpaceById::::get(space_id) - .ok_or(DispatchError::Other("Space not found"))?; - - Ok(space) -} - -benchmarks! { - - follow_space { - let space_owner_origin = RawOrigin::Signed(account::("SpaceOwner", 2, 0)); - let space_follower = account::("SpaceFollower", 1, 0); - - let space = create_dummy_space::(space_owner_origin.clone())?; - }: _(RawOrigin::Signed(space_follower.clone()), space.id) - verify { - ensure!(SpaceFollowers::::get(space.id).contains(&space_follower), "SpaceFollowers was not updated"); - ensure!(SpaceFollowedByAccount::::get(&(space_follower.clone(), space.id)), "SpaceFollowedByAccount was not updated"); - ensure!(SpacesFollowedByAccount::::get(&space_follower).contains(&space.id), "SpacesFollowedByAccount was not updated"); - } - - unfollow_space { - let space_owner_origin = RawOrigin::Signed(account::("SpaceOwner", 2, 0)); - let space_follower = account::("SpaceFollower", 1, 0); - - let space = create_dummy_space::(space_owner_origin.clone())?; - Pallet::::follow_space(RawOrigin::Signed(space_follower.clone()).into(),space.id)?; - - }: _(RawOrigin::Signed(space_follower.clone()), space.id) - verify { - ensure!(!SpaceFollowers::::get(space.id).contains(&space_follower), "SpaceFollowers was not updated"); - ensure!(!SpaceFollowedByAccount::::get(&(space_follower.clone(), space.id)), "SpaceFollowedByAccount was not updated"); - ensure!(!SpacesFollowedByAccount::::get(&space_follower).contains(&space.id), "SpacesFollowedByAccount was not updated"); - } -} diff --git a/pallets/space-follows/src/lib.rs b/pallets/space-follows/src/lib.rs deleted file mode 100644 index 95a3f62..0000000 --- a/pallets/space-follows/src/lib.rs +++ /dev/null @@ -1,170 +0,0 @@ -#![cfg_attr(not(feature = "std"), no_std)] - -pub use pallet::*; - -use frame_support::dispatch::DispatchResult; - -use pallet_spaces::Pallet as Spaces; - -#[cfg(feature = "runtime-benchmarks")] -mod benchmarking; -pub mod weights; - -// pub mod rpc; - -#[frame_support::pallet] -pub mod pallet { - use super::*; - - use crate::weights::WeightInfo; - use frame_support::pallet_prelude::*; - use frame_system::pallet_prelude::*; - use sp_std::vec::Vec; - use subsocial_support::{ - remove_from_vec, - traits::{IsAccountBlocked, SpaceFollowsProvider}, - ModerationError, SpaceId, - }; - - #[pallet::config] - pub trait Config: frame_system::Config + pallet_spaces::Config { - /// The overarching event type. - type RuntimeEvent: From> + IsType<::RuntimeEvent>; - - type WeightInfo: WeightInfo; - } - - #[pallet::pallet] - #[pallet::generate_store(pub(super) trait Store)] - #[pallet::without_storage_info] - pub struct Pallet(_); - - #[pallet::error] - pub enum Error { - /// Account is already a space follower. - AlreadySpaceFollower, - /// Account is not a space follower. - NotSpaceFollower, - /// Not allowed to follow a hidden space. - CannotFollowHiddenSpace, - } - - #[pallet::storage] - #[pallet::getter(fn space_followers)] - pub type SpaceFollowers = - StorageMap<_, Twox64Concat, SpaceId, Vec, ValueQuery>; - - #[pallet::storage] - #[pallet::getter(fn space_followed_by_account)] - pub type SpaceFollowedByAccount = - StorageMap<_, Blake2_128Concat, (T::AccountId, SpaceId), bool, ValueQuery>; - - #[pallet::storage] - #[pallet::getter(fn spaces_followed_by_account)] - pub type SpacesFollowedByAccount = - StorageMap<_, Twox64Concat, T::AccountId, Vec, ValueQuery>; - - #[pallet::event] - #[pallet::generate_deposit(pub(super) fn deposit_event)] - pub enum Event { - SpaceFollowed { follower: T::AccountId, space_id: SpaceId }, - SpaceUnfollowed { follower: T::AccountId, space_id: SpaceId }, - } - - #[pallet::call] - impl Pallet { - #[pallet::call_index(0)] - #[pallet::weight(::WeightInfo::follow_space())] - pub fn follow_space(origin: OriginFor, space_id: SpaceId) -> DispatchResult { - let follower = ensure_signed(origin)?; - - ensure!( - !Self::space_followed_by_account((follower.clone(), space_id)), - Error::::AlreadySpaceFollower - ); - - let space = Spaces::::require_space(space_id)?; - ensure!(!space.hidden, Error::::CannotFollowHiddenSpace); - - ensure!( - T::IsAccountBlocked::is_allowed_account(follower.clone(), space.id), - ModerationError::AccountIsBlocked - ); - - Self::add_space_follower(follower, space_id); - - Ok(()) - } - - #[pallet::call_index(1)] - #[pallet::weight(::WeightInfo::unfollow_space())] - pub fn unfollow_space(origin: OriginFor, space_id: SpaceId) -> DispatchResult { - let follower = ensure_signed(origin)?; - - Spaces::::ensure_space_exists(space_id)?; - - ensure!( - Self::space_followed_by_account((follower.clone(), space_id)), - Error::::NotSpaceFollower - ); - - Self::remove_space_follower(follower, space_id) - } - - #[pallet::call_index(2)] - #[pallet::weight(( - Weight::from_ref_time(100_000) + T::DbWeight::get().reads_writes(3, 4), - DispatchClass::Operational, - Pays::Yes, - ))] - pub fn force_follow_space( - origin: OriginFor, - follower: T::AccountId, - space_id: SpaceId, - ) -> DispatchResultWithPostInfo { - ensure_root(origin)?; - - ensure!( - !Self::space_followed_by_account((follower.clone(), space_id)), - Error::::AlreadySpaceFollower - ); - - Self::add_space_follower(follower, space_id); - - Ok(Pays::No.into()) - } - } - - impl Pallet { - fn add_space_follower(follower: T::AccountId, space_id: SpaceId) { - SpaceFollowers::::mutate(space_id, |followers| followers.push(follower.clone())); - SpaceFollowedByAccount::::insert((follower.clone(), space_id), true); - SpacesFollowedByAccount::::mutate(follower.clone(), |space_ids| { - space_ids.push(space_id) - }); - - Self::deposit_event(Event::SpaceFollowed { follower, space_id }); - } - - pub fn remove_space_follower(follower: T::AccountId, space_id: SpaceId) -> DispatchResult { - SpacesFollowedByAccount::::mutate(follower.clone(), |space_ids| { - remove_from_vec(space_ids, space_id) - }); - SpaceFollowers::::mutate(space_id, |account_ids| { - remove_from_vec(account_ids, follower.clone()) - }); - SpaceFollowedByAccount::::remove((follower.clone(), space_id)); - - Self::deposit_event(Event::SpaceUnfollowed { follower, space_id }); - Ok(()) - } - } - - impl SpaceFollowsProvider for Pallet { - type AccountId = T::AccountId; - - fn is_space_follower(account: Self::AccountId, space_id: SpaceId) -> bool { - Pallet::::space_followed_by_account((account, space_id)) - } - } -} diff --git a/pallets/space-follows/src/rpc.rs b/pallets/space-follows/src/rpc.rs deleted file mode 100644 index f82c979..0000000 --- a/pallets/space-follows/src/rpc.rs +++ /dev/null @@ -1,17 +0,0 @@ -use sp_std::prelude::*; - -use pallet_utils::SpaceId; - -use crate::{Config, Pallet}; - -impl Pallet { - pub fn get_space_ids_followed_by_account(account: T::AccountId) -> Vec { - Self::spaces_followed_by_account(account) - } - - pub fn filter_followed_space_ids(account: T::AccountId, space_ids: Vec) -> Vec { - space_ids.iter() - .filter(|space_id| Self::space_followed_by_account((&account, space_id))) - .cloned().collect() - } -} \ No newline at end of file diff --git a/pallets/space-follows/src/weights.rs b/pallets/space-follows/src/weights.rs deleted file mode 100644 index b725216..0000000 --- a/pallets/space-follows/src/weights.rs +++ /dev/null @@ -1,95 +0,0 @@ - -//! Autogenerated weights for pallet_space_follows -//! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-02-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! HOSTNAME: `benchmarks-ci`, CPU: `Intel(R) Xeon(R) Platinum 8280 CPU @ 2.70GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 - -// Executed Command: - // ./scripts/../target/release/subsocial-collator - // benchmark - // pallet - // --chain - // dev - // --execution - // wasm - // --wasm-execution - // Compiled - // --pallet - // pallet_space_follows - // --extrinsic - // * - // --steps - // 50 - // --repeat - // 20 - // --heap-pages - // 4096 - // --output - // pallets/space-follows/src/weights.rs - // --template - // ./.maintain/weight-template.hbs - -#![cfg_attr(rustfmt, rustfmt_skip)] -#![allow(unused_parens)] -#![allow(unused_imports)] -#![allow(non_snake_case)] - -use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; -use sp_std::marker::PhantomData; - -/// Weight functions needed for pallet_space_follows. -pub trait WeightInfo { - fn follow_space() -> Weight; - fn unfollow_space() -> Weight; -} - -/// Weights for pallet_space_follows using the Substrate node and recommended hardware. -pub struct SubstrateWeight(PhantomData); - impl WeightInfo for SubstrateWeight { - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:1) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowers (r:1 w:1) - // Storage: SpaceFollows SpacesFollowedByAccount (r:1 w:1) - fn follow_space() -> Weight { - // Minimum execution time: 48_140 nanoseconds. - Weight::from_ref_time(48_862_000) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(3)) - } - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:1) - // Storage: SpaceFollows SpacesFollowedByAccount (r:1 w:1) - // Storage: SpaceFollows SpaceFollowers (r:1 w:1) - fn unfollow_space() -> Weight { - // Minimum execution time: 55_112 nanoseconds. - Weight::from_ref_time(55_868_000) - .saturating_add(T::DbWeight::get().reads(4)) - .saturating_add(T::DbWeight::get().writes(3)) - } - } - - // For backwards compatibility and tests - impl WeightInfo for () { - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:1) - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowers (r:1 w:1) - // Storage: SpaceFollows SpacesFollowedByAccount (r:1 w:1) - fn follow_space() -> Weight { - // Minimum execution time: 48_140 nanoseconds. - Weight::from_ref_time(48_862_000) - .saturating_add(RocksDbWeight::get().reads(4)) - .saturating_add(RocksDbWeight::get().writes(3)) - } - // Storage: Spaces SpaceById (r:1 w:0) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:1) - // Storage: SpaceFollows SpacesFollowedByAccount (r:1 w:1) - // Storage: SpaceFollows SpaceFollowers (r:1 w:1) - fn unfollow_space() -> Weight { - // Minimum execution time: 55_112 nanoseconds. - Weight::from_ref_time(55_868_000) - .saturating_add(RocksDbWeight::get().reads(4)) - .saturating_add(RocksDbWeight::get().writes(3)) - } - } diff --git a/pallets/space-follows/tests/Cargo.toml b/pallets/space-follows/tests/Cargo.toml deleted file mode 100644 index 8eac0c0..0000000 --- a/pallets/space-follows/tests/Cargo.toml +++ /dev/null @@ -1,58 +0,0 @@ -[package] -name = 'pallet-space-follows-tests' -version = '0.1.7' -authors = ['DappForce '] -edition = '2021' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Tests for Space Follows pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[package.metadata.docs.rs] -targets = ["x86_64-unknown-linux-gnu"] - -[dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } - -# Local dependencies -subsocial-support = { default-features = false, path = '../../support' } -pallet-permissions = { default-features = false, path = '../../permissions' } -pallet-space-follows = { default-features = false, path = '..' } - -# Substrate dependencies -pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } - -[dev-dependencies] -sp-core = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-io = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } -pallet-roles = { default-features = false, path = '../../roles' } -pallet-profiles = { default-features = false, path = '../../profiles' } -pallet-posts = { default-features = false, path = '../../posts' } -pallet-spaces = { default-features = false, path = '../../spaces' } - -[features] -default = ['std'] -std = [ - 'codec/std', - 'scale-info/std', - 'pallet-timestamp/std', - 'frame-support/std', - 'frame-system/std', - 'sp-runtime/std', - 'sp-std/std', - 'pallet-permissions/std', - 'pallet-balances/std', - 'pallet-roles/std', - 'pallet-space-follows/std', - 'pallet-profiles/std', - 'pallet-posts/std', -] -try-runtime = ["frame-support/try-runtime"] diff --git a/pallets/space-follows/tests/src/lib.rs b/pallets/space-follows/tests/src/lib.rs deleted file mode 100644 index 71dc193..0000000 --- a/pallets/space-follows/tests/src/lib.rs +++ /dev/null @@ -1,6 +0,0 @@ -#[cfg(test)] -mod mock; -#[cfg(test)] -mod tests; -#[cfg(test)] -mod tests_utils; diff --git a/pallets/space-follows/tests/src/mock.rs b/pallets/space-follows/tests/src/mock.rs deleted file mode 100644 index c6559e5..0000000 --- a/pallets/space-follows/tests/src/mock.rs +++ /dev/null @@ -1,122 +0,0 @@ -use frame_support::{pallet_prelude::ConstU32, parameter_types, traits::Everything}; -use sp_core::H256; -use sp_runtime::{ - testing::Header, - traits::{BlakeTwo256, IdentityLookup}, -}; -use sp_std::convert::{TryFrom, TryInto}; - -type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; -type Block = frame_system::mocking::MockBlock; - -frame_support::construct_runtime!( - pub enum Test where - Block = Block, - NodeBlock = Block, - UncheckedExtrinsic = UncheckedExtrinsic, - { - System: frame_system, - Timestamp: pallet_timestamp, - Balances: pallet_balances, - Permissions: pallet_permissions, - Roles: pallet_roles, - SpaceFollows: pallet_space_follows, - Spaces: pallet_spaces, - } -); - -pub(super) type AccountId = u64; -pub(super) type Balance = u64; -pub(super) type BlockNumber = u64; - -parameter_types! { - pub const BlockHashCount: u64 = 250; - pub const SS58Prefix: u8 = 42; -} - -impl frame_system::Config for Test { - type BaseCallFilter = Everything; - type BlockWeights = (); - type BlockLength = (); - type RuntimeOrigin = RuntimeOrigin; - type RuntimeCall = RuntimeCall; - type Index = u64; - type BlockNumber = BlockNumber; - type Hash = H256; - type Hashing = BlakeTwo256; - type AccountId = AccountId; - type Lookup = IdentityLookup; - type Header = Header; - type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; - type DbWeight = (); - type Version = (); - type PalletInfo = PalletInfo; - type AccountData = pallet_balances::AccountData; - type OnNewAccount = (); - type OnKilledAccount = (); - type SystemWeightInfo = (); - type SS58Prefix = SS58Prefix; - type OnSetCode = (); - type MaxConsumers = frame_support::traits::ConstU32<16>; -} - -parameter_types! { - pub const MinimumPeriod: u64 = 5; -} - -impl pallet_timestamp::Config for Test { - type Moment = u64; - type OnTimestampSet = (); - type MinimumPeriod = MinimumPeriod; - type WeightInfo = (); -} - -parameter_types! { - pub const ExistentialDeposit: u64 = 1; -} - -impl pallet_balances::Config for Test { - type Balance = Balance; - type DustRemoval = (); - type RuntimeEvent = RuntimeEvent; - type ExistentialDeposit = ExistentialDeposit; - type AccountStore = System; - type WeightInfo = (); - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = (); -} - -impl pallet_permissions::Config for Test { - type DefaultSpacePermissions = pallet_permissions::default_permissions::DefaultSpacePermissions; -} - -parameter_types! { - pub const MaxUsersToProcessPerDeleteRole: u16 = 40; -} - -impl pallet_roles::Config for Test { - type RuntimeEvent = RuntimeEvent; - type MaxUsersToProcessPerDeleteRole = MaxUsersToProcessPerDeleteRole; - type SpacePermissionsProvider = Spaces; - type SpaceFollows = SpaceFollows; - type IsAccountBlocked = (); - type IsContentBlocked = (); - type WeightInfo = (); -} - -impl pallet_spaces::Config for Test { - type RuntimeEvent = RuntimeEvent; - type Roles = Roles; - type SpaceFollows = SpaceFollows; - type IsAccountBlocked = (); - type IsContentBlocked = (); - type MaxSpacesPerAccount = ConstU32<100>; - type WeightInfo = (); -} - -impl pallet_space_follows::Config for Test { - type RuntimeEvent = RuntimeEvent; - type WeightInfo = (); -} diff --git a/pallets/space-follows/tests/src/tests.rs b/pallets/space-follows/tests/src/tests.rs deleted file mode 100644 index 8764de8..0000000 --- a/pallets/space-follows/tests/src/tests.rs +++ /dev/null @@ -1,65 +0,0 @@ -use crate::{mock::*, tests_utils::*}; -use frame_support::{assert_noop, assert_ok}; -use pallet_space_follows::Error as SpaceFollowsError; -use pallet_spaces::Error as SpacesError; - -#[test] -fn follow_space_should_work() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!(_default_follow_space()); // Follow SpaceId 1 by ACCOUNT2 - - assert_eq!(SpaceFollows::spaces_followed_by_account(ACCOUNT2), vec![SPACE1]); - assert_eq!(SpaceFollows::space_followers(SPACE1), vec![ACCOUNT2]); - assert!(SpaceFollows::space_followed_by_account((ACCOUNT2, SPACE1))); - }); -} - -#[test] -fn follow_space_should_fail_when_space_not_found() { - ExtBuilder::build().execute_with(|| { - assert_noop!(_default_follow_space(), SpacesError::::SpaceNotFound); - }); -} - -#[test] -fn follow_space_should_fail_when_account_is_already_space_follower() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!(_default_follow_space()); // Follow SpaceId 1 by ACCOUNT2 - - assert_noop!(_default_follow_space(), SpaceFollowsError::::AlreadySpaceFollower); - }); -} - -#[test] -fn follow_space_should_fail_when_trying_to_follow_hidden_space() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!(_update_space(None, None, Some(space_update(None, Some(true))))); - - assert_noop!(_default_follow_space(), SpaceFollowsError::::CannotFollowHiddenSpace); - }); -} - -#[test] -fn unfollow_space_should_work() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!(_default_follow_space()); - // Follow SpaceId 1 by ACCOUNT2 - assert_ok!(_default_unfollow_space()); - - assert!(SpaceFollows::spaces_followed_by_account(ACCOUNT2).is_empty()); - assert!(SpaceFollows::space_followers(SPACE1).is_empty()); - }); -} -#[test] -fn unfollow_space_should_fail_when_space_not_found() { - ExtBuilder::build_with_space_follow_no_space().execute_with(|| { - assert_noop!(_default_unfollow_space(), SpacesError::::SpaceNotFound); - }); -} - -#[test] -fn unfollow_space_should_fail_when_account_is_not_space_follower_yet() { - ExtBuilder::build_with_space().execute_with(|| { - assert_noop!(_default_unfollow_space(), SpaceFollowsError::::NotSpaceFollower); - }); -} diff --git a/pallets/space-follows/tests/src/tests_utils.rs b/pallets/space-follows/tests/src/tests_utils.rs deleted file mode 100644 index eea6f25..0000000 --- a/pallets/space-follows/tests/src/tests_utils.rs +++ /dev/null @@ -1,134 +0,0 @@ -use frame_support::{assert_ok, pallet_prelude::*}; -use pallet_permissions::SpacePermissions; -use pallet_spaces::{types::SpaceUpdate, SpaceById}; -use sp_core::storage::Storage; -use sp_io::TestExternalities; -use subsocial_support::{Content, SpaceId}; - -use crate::mock::*; - -////// Ext Builder - -pub struct ExtBuilder; - -impl ExtBuilder { - fn configure_storages(storage: &mut Storage) { - let mut accounts = Vec::new(); - for account in ACCOUNT1..=ACCOUNT3 { - accounts.push(account); - } - - let _ = pallet_balances::GenesisConfig:: { - balances: accounts.iter().cloned().map(|k| (k, 100)).collect(), - } - .assimilate_storage(storage); - } - - /// Default ext configuration with BlockNumber 1 - pub fn build() -> TestExternalities { - let mut storage = frame_system::GenesisConfig::default().build_storage::().unwrap(); - - Self::configure_storages(&mut storage); - - let mut ext = TestExternalities::from(storage); - ext.execute_with(|| System::set_block_number(1)); - - ext - } - - fn add_default_space() { - assert_ok!(_create_default_space()); - } - - /// Custom ext configuration with SpaceId 1 and BlockNumber 1 - pub fn build_with_space() -> TestExternalities { - let mut ext = Self::build(); - ext.execute_with(Self::add_default_space); - ext - } - - /// Custom ext configuration with space follow without Space - pub fn build_with_space_follow_no_space() -> TestExternalities { - let mut ext = Self::build_with_space(); - - ext.execute_with(|| { - assert_ok!(_default_follow_space()); - >::remove(SPACE1); - }); - - ext - } -} - -////// Consts - -pub(crate) const ACCOUNT1: AccountId = 1; -pub(crate) const ACCOUNT2: AccountId = 2; -pub(crate) const ACCOUNT3: AccountId = 3; - -pub(crate) const SPACE1: SpaceId = 1001; - -///////////// Space Utils - -pub(crate) fn space_content_ipfs() -> Content { - Content::IPFS(b"bafyreib3mgbou4xln42qqcgj6qlt3cif35x4ribisxgq7unhpun525l54e".to_vec()) -} - -pub(crate) fn space_update(content: Option, hidden: Option) -> SpaceUpdate { - SpaceUpdate { content, hidden, permissions: None } -} - -pub(crate) fn _create_default_space() -> DispatchResult { - _create_space(None, None, None, None) -} - -pub(crate) fn _create_space( - origin: Option, - // FIXME: we don't have handles anymore - _handle: Option>>, - content: Option, - permissions: Option>, -) -> DispatchResult { - Spaces::create_space( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - content.unwrap_or_else(space_content_ipfs), - permissions.unwrap_or_default(), - ) -} - - -pub(crate) fn _update_space( - origin: Option, - space_id: Option, - update: Option, -) -> DispatchResult { - Spaces::update_space( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - space_id.unwrap_or(SPACE1), - update.unwrap_or_else(|| space_update(None, None)), - ) -} - -//// Space follows utils - -pub(crate) fn _default_follow_space() -> DispatchResult { - _follow_space(None, None) -} - -pub(crate) fn _follow_space(origin: Option, space_id: Option) -> DispatchResult { - SpaceFollows::follow_space( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT2)), - space_id.unwrap_or(SPACE1), - ) -} - -pub(crate) fn _default_unfollow_space() -> DispatchResult { - _unfollow_space(None, None) -} - -pub(crate) fn _unfollow_space(origin: Option, space_id: Option) -> DispatchResult { - SpaceFollows::unfollow_space( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT2)), - space_id.unwrap_or(SPACE1), - ) -} diff --git a/pallets/spaces/Cargo.toml b/pallets/spaces/Cargo.toml deleted file mode 100644 index 0cc02c2..0000000 --- a/pallets/spaces/Cargo.toml +++ /dev/null @@ -1,48 +0,0 @@ -[package] -name = 'pallet-spaces' -version = '0.1.7' -authors = ['DappForce '] -edition = '2021' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Space management pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[package.metadata.docs.rs] -targets = ["x86_64-unknown-linux-gnu"] - -[dependencies] -impl-trait-for-tuples = '0.2.2' -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } - -# Local dependencies -subsocial-support = { default-features = false, path = '../support' } -pallet-permissions = { default-features = false, path = '../permissions' } - -# Substrate dependencies -pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-benchmarking = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false, optional = true } -frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } - -[features] -default = ['std'] -runtime-benchmarks = ['frame-benchmarking/runtime-benchmarks'] -std = [ - 'codec/std', - 'scale-info/std', - 'pallet-timestamp/std', - 'frame-benchmarking/std', - 'frame-support/std', - 'frame-system/std', - 'sp-runtime/std', - 'sp-std/std', - 'subsocial-support/std', - 'pallet-permissions/std' -] -try-runtime = ['frame-support/try-runtime'] diff --git a/pallets/spaces/rpc/Cargo.toml b/pallets/spaces/rpc/Cargo.toml deleted file mode 100644 index e302671..0000000 --- a/pallets/spaces/rpc/Cargo.toml +++ /dev/null @@ -1,51 +0,0 @@ -[package] -name = 'spaces-rpc' -version = '0.7.3' -authors = ['DappForce '] -edition = '2018' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'RPC methods for the spaces pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[dependencies.serde] -optional = true -features = ['derive'] -version = '1.0.119' - -[dependencies.codec] -default-features = false -features = ['derive'] -package = 'parity-scale-codec' -version = '2.0.0' - -[dependencies] -jsonrpc-core = '18.0.0' -jsonrpc-core-client = '18.0.0' -jsonrpc-derive = '18.0.0' - -# Local dependencies -pallet-spaces = { default-features = false, path = '..' } -pallet-utils = { default-features = false, path = '../../utils' } - -# Custom Runtime API -spaces-runtime-api = { default-features = false, path = 'runtime-api' } - -# Substrate dependencies -sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-blockchain = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-rpc = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } - -[features] -default = ['std'] -std = [ - 'serde', - 'sp-runtime/std', - 'sp-api/std', - 'spaces-runtime-api/std', - 'pallet-spaces/std', - 'pallet-utils/std' -] diff --git a/pallets/spaces/rpc/runtime-api/Cargo.toml b/pallets/spaces/rpc/runtime-api/Cargo.toml deleted file mode 100644 index 0b7cefb..0000000 --- a/pallets/spaces/rpc/runtime-api/Cargo.toml +++ /dev/null @@ -1,43 +0,0 @@ -[package] -name = 'spaces-runtime-api' -version = '0.7.3' -authors = ['DappForce '] -edition = '2018' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Runtime API definition for the spaces pallet' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[dependencies.serde] -optional = true -features = ["derive"] -version = "1.0.119" - -[dependencies.codec] -default-features = false -features = ['derive'] -package = 'parity-scale-codec' -version = '2.0.0' - -[dependencies] -# Local dependencies -pallet-spaces = { default-features = false, path = '../..' } -pallet-utils = { default-features = false, path = '../../../utils' } - -# Substrate dependencies -sp-api = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.12', default-features = false } - -[features] -default = ['std'] -std = [ - 'serde', - 'sp-api/std', - 'sp-std/std', - 'sp-runtime/std', - 'pallet-spaces/std', - 'pallet-utils/std' -] diff --git a/pallets/spaces/rpc/runtime-api/src/lib.rs b/pallets/spaces/rpc/runtime-api/src/lib.rs deleted file mode 100644 index bfa02e6..0000000 --- a/pallets/spaces/rpc/runtime-api/src/lib.rs +++ /dev/null @@ -1,32 +0,0 @@ -#![cfg_attr(not(feature = "std"), no_std)] - -use codec::Codec; -use sp_std::vec::Vec; - -use pallet_spaces::rpc::FlatSpace; -use pallet_utils::SpaceId; - -sp_api::decl_runtime_apis! { - pub trait SpacesApi where - AccountId: Codec, - BlockNumber: Codec - { - fn get_next_space_id() -> SpaceId; - - fn get_spaces(start_id: u64, limit: u64) -> Vec>; - - fn get_spaces_by_ids(space_ids: Vec) -> Vec>; - - fn get_public_spaces(start_id: u64, limit: u64) -> Vec>; - - fn get_unlisted_spaces(start_id: u64, limit: u64) -> Vec>; - - fn get_public_space_ids_by_owner(owner: AccountId) -> Vec; - - fn get_unlisted_space_ids_by_owner(owner: AccountId) -> Vec; - - fn get_space_by_handle(handle: Vec) -> Option>; - - fn get_space_id_by_handle(handle: Vec) -> Option; - } -} diff --git a/pallets/spaces/rpc/src/lib.rs b/pallets/spaces/rpc/src/lib.rs deleted file mode 100644 index af68f3e..0000000 --- a/pallets/spaces/rpc/src/lib.rs +++ /dev/null @@ -1,195 +0,0 @@ -use std::sync::Arc; -use codec::Codec; -use sp_blockchain::HeaderBackend; -use sp_runtime::{generic::BlockId, traits::Block as BlockT}; -use jsonrpc_core::Result; -use jsonrpc_derive::rpc; -use sp_api::ProvideRuntimeApi; - -use pallet_spaces::rpc::FlatSpace; -use pallet_utils::{SpaceId, rpc::map_rpc_error}; -pub use spaces_runtime_api::SpacesApi as SpacesRuntimeApi; - -#[rpc] -pub trait SpacesApi { - #[rpc(name = "spaces_getSpaces")] - fn get_spaces( - &self, - at: Option, - start_id: u64, - limit: u64, - ) -> Result>>; - - #[rpc(name = "spaces_getSpacesByIds")] - fn get_spaces_by_ids( - &self, - at: Option, - space_ids: Vec, - ) -> Result>>; - - #[rpc(name = "spaces_getPublicSpaces")] - fn get_public_spaces( - &self, - at: Option, - start_id: u64, - limit: u64, - ) -> Result>>; - - #[rpc(name = "spaces_getUnlistedSpaces")] - fn get_unlisted_spaces( - &self, - at: Option, - start_id: u64, - limit: u64, - ) -> Result>>; - - #[rpc(name = "spaces_getSpaceIdByHandle")] - fn get_space_id_by_handle( - &self, - at: Option, - handle: Vec, - ) -> Result>; - - #[rpc(name = "spaces_getSpaceByHandle")] - fn get_space_by_handle( - &self, - at: Option, - handle: Vec, - ) -> Result>>; - - #[rpc(name = "spaces_getPublicSpaceIdsByOwner")] - fn get_public_space_ids_by_owner( - &self, - at: Option, - owner: AccountId, - ) -> Result>; - - #[rpc(name = "spaces_getUnlistedSpaceIdsByOwner")] - fn get_unlisted_space_ids_by_owner( - &self, - at: Option, - owner: AccountId, - ) -> Result>; - - #[rpc(name = "spaces_nextSpaceId")] - fn get_next_space_id(&self, at: Option) -> Result; -} - -pub struct Spaces { - client: Arc, - _marker: std::marker::PhantomData, -} - -impl Spaces { - pub fn new(client: Arc) -> Self { - Self { - client, - _marker: Default::default(), - } - } -} - -impl SpacesApi<::Hash, AccountId, BlockNumber> - for Spaces -where - Block: BlockT, - AccountId: Codec, - BlockNumber: Codec, - C: Send + Sync + 'static + ProvideRuntimeApi + HeaderBackend, - C::Api: SpacesRuntimeApi, -{ - fn get_spaces( - &self, - at: Option<::Hash>, - start_id: u64, - limit: u64, - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_spaces(&at, start_id, limit); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_spaces_by_ids( - &self, - at: Option<::Hash>, - space_ids: Vec, - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_spaces_by_ids(&at, space_ids); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_public_spaces( - &self, - at: Option<::Hash>, - start_id: u64, - limit: u64, - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_public_spaces(&at, start_id, limit); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_unlisted_spaces( - &self, - at: Option<::Hash>, - start_id: u64, - limit: u64, - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_unlisted_spaces(&at, start_id, limit); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_space_id_by_handle(&self, at: Option<::Hash>, handle: Vec) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_space_id_by_handle(&at, handle); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_space_by_handle( - &self, - at: Option<::Hash>, - handle: Vec, - ) -> Result>> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_space_by_handle(&at, handle); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_public_space_ids_by_owner(&self, at: Option<::Hash>, owner: AccountId) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_public_space_ids_by_owner(&at, owner); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_unlisted_space_ids_by_owner(&self, at: Option<::Hash>, owner: AccountId) -> Result> { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_unlisted_space_ids_by_owner(&at, owner); - runtime_api_result.map_err(map_rpc_error) - } - - fn get_next_space_id(&self, at: Option<::Hash>) -> Result { - let api = self.client.runtime_api(); - let at = BlockId::hash(at.unwrap_or_else(|| self.client.info().best_hash)); - - let runtime_api_result = api.get_next_space_id(&at); - runtime_api_result.map_err(map_rpc_error) - } -} diff --git a/pallets/spaces/src/benchmarking.rs b/pallets/spaces/src/benchmarking.rs deleted file mode 100644 index f37f714..0000000 --- a/pallets/spaces/src/benchmarking.rs +++ /dev/null @@ -1,57 +0,0 @@ -//! Spaces pallet benchmarking. - -use frame_benchmarking::{benchmarks, whitelisted_caller}; -use frame_support::{assert_ok, ensure, pallet_prelude::Get}; -use frame_system::RawOrigin; - -use crate::{types::*, Config}; - -use super::*; - -fn dummy_space_content() -> Content { - subsocial_support::mock_functions::valid_content_ipfs() -} - -fn create_dummy_space(caller: T::AccountId) -> Space { - assert_ok!(Pallet::::create_space(RawOrigin::Signed(caller).into(), Content::None, None)); - let id = Pallet::::next_space_id() - 1; - - SpaceById::::get(id).expect("qed; space should exist") -} - -benchmarks! { - create_space { - let caller = whitelisted_caller::(); - - let parent_space = create_dummy_space::(caller.clone()); - let new_space_id = NextSpaceId::::get(); - - let content = dummy_space_content(); - let permissions_opt = None; - }: _(RawOrigin::Signed(caller), content, permissions_opt) - verify { - ensure!(SpaceById::::get(new_space_id).is_some(), "Created space should exist"); - } - - update_space { - let caller = whitelisted_caller::(); - - let space = create_dummy_space::(caller.clone()); - let new_parent_space = create_dummy_space::(caller.clone()); - - assert!(space.content.is_none()); - assert!(space.permissions.is_none()); - - let space_update = SpaceUpdate { - content: dummy_space_content().into(), - hidden: true.into(), - permissions: Some(Some(::DefaultSpacePermissions::get())), - }; - }: _(RawOrigin::Signed(caller), space.id, space_update) - verify { - let space_from_storage = SpaceById::::get(space.id).expect("Updated space should exist"); - assert!(space_from_storage.content.is_some()); - assert!(space_from_storage.edited); - assert!(space_from_storage.permissions.is_some()); - } -} diff --git a/pallets/spaces/src/lib.rs b/pallets/spaces/src/lib.rs deleted file mode 100644 index b86c63e..0000000 --- a/pallets/spaces/src/lib.rs +++ /dev/null @@ -1,434 +0,0 @@ -//! # Spaces Module -//! -//! Spaces are the primary components of Subsocial. This module allows you to create a Space -//! and customize it by updating its' owner(s), content, and permissions. -//! -//! To understand how Spaces fit into the Subsocial ecosystem, you can think of how -//! folders and files work in a file system. Spaces are similar to folders, that can contain Posts, -//! in this sense. The permissions of the Space and Posts can be customized so that a Space -//! could be as simple as a personal blog (think of a page on Facebook) or as complex as community -//! (think of a subreddit) governed DAO. -//! -//! Spaces can be compared to existing entities on web 2.0 platforms such as: -//! -//! - Blogs on Blogger, -//! - Publications on Medium, -//! - Groups or pages on Facebook, -//! - Accounts on Twitter and Instagram, -//! - Channels on YouTube, -//! - Servers on Discord, -//! - Forums on Discourse. - -#![cfg_attr(not(feature = "std"), no_std)] - -pub use pallet::*; -use pallet_permissions::{SpacePermission, SpacePermissions}; -use subsocial_support::{traits::SpaceFollowsProvider, Content, SpaceId}; - -#[cfg(feature = "runtime-benchmarks")] -mod benchmarking; -pub mod weights; - -// pub mod rpc; -pub mod types; - -#[frame_support::pallet] -pub mod pallet { - use frame_support::pallet_prelude::*; - use frame_system::pallet_prelude::*; - use sp_std::vec::Vec; - - use pallet_permissions::{ - Pallet as Permissions, PermissionChecker, SpacePermissionsContext, SpacePermissionsInfoOf, - }; - use subsocial_support::{ - ensure_content_is_valid, remove_from_bounded_vec, - traits::{IsAccountBlocked, IsContentBlocked, SpacePermissionsProvider, SpacesInterface}, - ModerationError, SpacePermissionsInfo, WhoAndWhen, WhoAndWhenOf, - }; - use types::*; - - pub use crate::weights::WeightInfo; - - use super::*; - - #[pallet::config] - pub trait Config: - frame_system::Config + pallet_permissions::Config + pallet_timestamp::Config - { - /// The overarching event type. - type RuntimeEvent: From> + IsType<::RuntimeEvent>; - - type Roles: PermissionChecker; - - type SpaceFollows: SpaceFollowsProvider; - - type IsAccountBlocked: IsAccountBlocked; - - type IsContentBlocked: IsContentBlocked; - - #[pallet::constant] - type MaxSpacesPerAccount: Get; - - /// Weight information for extrinsics in this pallet. - type WeightInfo: WeightInfo; - } - - #[pallet::pallet] - #[pallet::generate_store(pub (super) trait Store)] - #[pallet::without_storage_info] - pub struct Pallet(_); - - #[pallet::event] - #[pallet::generate_deposit(pub (super) fn deposit_event)] - pub enum Event { - SpaceCreated { account: T::AccountId, space_id: SpaceId }, - SpaceUpdated { account: T::AccountId, space_id: SpaceId }, - } - - #[pallet::error] - pub enum Error { - /// Space was not found by id. - SpaceNotFound, - /// Nothing to update in this space. - NoUpdatesForSpace, - /// Only space owners can manage this space. - NotASpaceOwner, - /// User has no permission to update this space. - NoPermissionToUpdateSpace, - /// User has no permission to create subspaces within this space. - NoPermissionToCreateSubspaces, - /// Space is at root level, no `parent_id` specified. - SpaceIsAtRoot, - /// New spaces' settings don't differ from the old ones. - NoUpdatesForSpacesSettings, - /// There are too many spaces created by this account already - TooManySpacesPerAccount, - } - - #[pallet::type_value] - pub fn DefaultForNextSpaceId() -> SpaceId { - RESERVED_SPACE_COUNT + 1 - } - - /// The next space id. - #[pallet::storage] - #[pallet::getter(fn next_space_id)] - pub type NextSpaceId = StorageValue<_, SpaceId, ValueQuery, DefaultForNextSpaceId>; - - /// Get the details of a space by its' id. - #[pallet::storage] - #[pallet::getter(fn space_by_id)] - pub type SpaceById = StorageMap<_, Twox64Concat, SpaceId, Space>; - - /// Find the ids of all spaces owned, by a given account. - #[pallet::storage] - #[pallet::getter(fn space_ids_by_owner)] - pub type SpaceIdsByOwner = - StorageMap<_, Twox64Concat, T::AccountId, SpacesByAccount, ValueQuery>; - - #[pallet::genesis_config] - pub struct GenesisConfig { - pub endowed_account: Option, - } - - #[cfg(feature = "std")] - impl Default for GenesisConfig { - fn default() -> Self { - Self { endowed_account: None } - } - } - - #[pallet::genesis_build] - impl GenesisBuild for GenesisConfig { - fn build(&self) { - Pallet::::init_pallet(self.endowed_account.as_ref()); - } - } - - #[pallet::call] - impl Pallet { - #[pallet::call_index(0)] - #[pallet::weight(< T as Config >::WeightInfo::create_space())] - pub fn create_space( - origin: OriginFor, - content: Content, - permissions_opt: Option, - ) -> DispatchResult { - let owner = ensure_signed(origin)?; - - Self::do_create_space(&owner, content, permissions_opt)?; - Ok(()) - } - - #[pallet::call_index(1)] - #[pallet::weight(< T as Config >::WeightInfo::update_space())] - pub fn update_space( - origin: OriginFor, - space_id: SpaceId, - update: SpaceUpdate, - ) -> DispatchResult { - let owner = ensure_signed(origin)?; - - let has_updates = - update.content.is_some() || update.hidden.is_some() || update.permissions.is_some(); - - ensure!(has_updates, Error::::NoUpdatesForSpace); - - let mut space = Self::require_space(space_id)?; - - ensure!( - T::IsAccountBlocked::is_allowed_account(owner.clone(), space.id), - ModerationError::AccountIsBlocked - ); - - Self::ensure_account_has_space_permission( - owner.clone(), - &space, - SpacePermission::UpdateSpace, - Error::::NoPermissionToUpdateSpace.into(), - )?; - - let mut is_update_applied = false; - - if let Some(content) = update.content { - if content != space.content { - ensure_content_is_valid(content.clone())?; - - ensure!( - T::IsContentBlocked::is_allowed_content(content.clone(), space.id), - ModerationError::ContentIsBlocked - ); - - space.content = content; - space.edited = true; - is_update_applied = true; - } - } - - if let Some(hidden) = update.hidden { - if hidden != space.hidden { - space.hidden = hidden; - is_update_applied = true; - } - } - - if let Some(overrides_opt) = update.permissions { - if space.permissions != overrides_opt { - if let Some(overrides) = overrides_opt.clone() { - space.permissions = Some(Permissions::::override_permissions(overrides)); - } else { - space.permissions = overrides_opt; - } - - is_update_applied = true; - } - } - - // Update this space only if at least one field should be updated: - if is_update_applied { - SpaceById::::insert(space_id, space); - Self::deposit_event(Event::SpaceUpdated { account: owner, space_id }); - } - Ok(()) - } - - #[pallet::call_index(2)] - #[pallet::weight(( - Weight::from_ref_time(1_000_000) + T::DbWeight::get().reads_writes(1, 3), - DispatchClass::Operational, - Pays::Yes, - ))] - pub fn force_create_space( - origin: OriginFor, - space_id: SpaceId, - created: WhoAndWhenOf, - owner: T::AccountId, - content: Content, - hidden: bool, - permissions_opt: Option, - ) -> DispatchResultWithPostInfo { - ensure_root(origin)?; - - let permissions = - permissions_opt.map(|perms| Permissions::::override_permissions(perms)); - - let WhoAndWhen { account, time, .. } = created; - let new_who_and_when = - WhoAndWhen { account, block: frame_system::Pallet::::block_number(), time }; - - let new_space = &mut Space { - id: space_id, - created: new_who_and_when, - edited: false, - owner: owner.clone(), - content, - hidden, - permissions, - }; - - let add_new_space_id_by_owner = |owner: &T::AccountId, space_id: SpaceId| { - SpaceIdsByOwner::::mutate(&owner, |ids| { - ids.try_push(space_id).expect("qed; too many spaces per account") - }); - }; - - // To prevent incorrect [SpaceIdsByOwner] insertion, - // we check if the space already exists. - match Self::require_space(space_id) { - Ok(space) if !space.is_owner(&owner) => { - SpaceIdsByOwner::::mutate(&space.owner, |ids| { - remove_from_bounded_vec(ids, space_id) - }); - add_new_space_id_by_owner(&owner, space_id); - }, - Err(_) => add_new_space_id_by_owner(&owner, space_id), - _ => (), - } - - SpaceById::::insert(space_id, new_space); - - Self::deposit_event(Event::SpaceCreated { account: owner, space_id }); - - Ok(Pays::No.into()) - } - - #[pallet::call_index(3)] - #[pallet::weight(( - Weight::from_ref_time(10_000) + T::DbWeight::get().writes(1), - DispatchClass::Operational, - Pays::Yes, - ))] - pub fn force_set_next_space_id( - origin: OriginFor, - space_id: SpaceId, - ) -> DispatchResultWithPostInfo { - ensure_root(origin)?; - NextSpaceId::::put(space_id); - Ok(Pays::No.into()) - } - } - - impl Pallet { - /// Create reserved spaces either on genesis build or when pallet is added to a runtime. - pub fn init_pallet(endowed_account_opt: Option<&T::AccountId>) { - if let Some(endowed_account) = endowed_account_opt { - let mut spaces = Vec::new(); - - for id in FIRST_SPACE_ID..=RESERVED_SPACE_COUNT { - spaces.push(( - id, - Space::::new(id, endowed_account.clone(), Content::None, None), - )); - } - spaces.iter().for_each(|(space_id, space)| { - SpaceById::::insert(space_id, space); - }); - } - } - - fn do_create_space( - owner: &T::AccountId, - content: Content, - permissions_opt: Option, - ) -> Result { - ensure_content_is_valid(content.clone())?; - Self::ensure_space_limit_not_reached(owner)?; - - let permissions = - permissions_opt.map(|perms| Permissions::::override_permissions(perms)); - - let space_id = Self::next_space_id(); - let new_space = &mut Space::new(space_id, owner.clone(), content, permissions); - - SpaceById::::insert(space_id, new_space); - SpaceIdsByOwner::::mutate(owner, |ids| { - ids.try_push(space_id).expect("qed; too many spaces per account") - }); - NextSpaceId::::mutate(|n| *n += 1); - - Self::deposit_event(Event::SpaceCreated { account: owner.clone(), space_id }); - Ok(space_id) - } - - /// Check that there is a `Space` with such `space_id` in the storage - /// or return`SpaceNotFound` error. - pub fn ensure_space_exists(space_id: SpaceId) -> DispatchResult { - ensure!(>::contains_key(space_id), Error::::SpaceNotFound); - Ok(()) - } - - /// Get `Space` by id from the storage or return `SpaceNotFound` error. - pub fn require_space(space_id: SpaceId) -> Result, DispatchError> { - Ok(Self::space_by_id(space_id).ok_or(Error::::SpaceNotFound)?) - } - - pub fn ensure_account_has_space_permission( - account: T::AccountId, - space: &Space, - permission: SpacePermission, - error: DispatchError, - ) -> DispatchResult { - let is_owner = space.is_owner(&account); - let is_follower = space.is_follower(&account); - - let ctx = SpacePermissionsContext { - space_id: space.id, - is_space_owner: is_owner, - is_space_follower: is_follower, - space_perms: space.permissions.clone(), - }; - - T::Roles::ensure_account_has_space_permission(account, ctx, permission, error) - } - - pub fn mutate_space_by_id)>( - space_id: SpaceId, - f: F, - ) -> Result, DispatchError> { - >::try_mutate(space_id, |space_opt| { - if let Some(ref mut space) = space_opt.clone() { - f(space); - *space_opt = Some(space.clone()); - - return Ok(space.clone()); - } - - Err(Error::::SpaceNotFound.into()) - }) - } - - pub fn ensure_space_limit_not_reached(owner: &T::AccountId) -> DispatchResult { - ensure!( - Self::space_ids_by_owner(&owner).len() < T::MaxSpacesPerAccount::get() as usize, - Error::::TooManySpacesPerAccount, - ); - Ok(()) - } - } - - impl SpacePermissionsProvider> for Pallet { - fn space_permissions_info(id: SpaceId) -> Result, DispatchError> { - let space = Pallet::::require_space(id)?; - - Ok(SpacePermissionsInfo { owner: space.owner, permissions: space.permissions }) - } - - fn ensure_space_owner(id: SpaceId, account: &T::AccountId) -> DispatchResult { - let space = Pallet::::require_space(id)?; - ensure!(space.is_owner(account), Error::::NotASpaceOwner); - Ok(()) - } - } - - impl SpacesInterface for Pallet { - fn get_space_owner(space_id: SpaceId) -> Result { - let space = Pallet::::require_space(space_id)?; - Ok(space.owner) - } - - fn create_space(owner: &T::AccountId, content: Content) -> Result { - Self::do_create_space(owner, content, None) - } - } -} diff --git a/pallets/spaces/src/rpc.rs b/pallets/spaces/src/rpc.rs deleted file mode 100644 index b63ab29..0000000 --- a/pallets/spaces/src/rpc.rs +++ /dev/null @@ -1,142 +0,0 @@ -use codec::{Decode, Encode}; -#[cfg(feature = "std")] -use serde::{Deserialize, Serialize}; -use sp_std::prelude::*; - -use pallet_utils::{bool_to_option, SpaceId, rpc::{FlatContent, FlatWhoAndWhen, ShouldSkip}}; - -use crate::{Config, Pallet, Space, FIRST_SPACE_ID}; - -#[derive(Eq, PartialEq, Encode, Decode, Default)] -#[cfg_attr(feature = "std", derive(Debug, Serialize, Deserialize))] -#[cfg_attr(feature = "std", serde(rename_all = "camelCase"))] -pub struct FlatSpace { - pub id: SpaceId, - - #[cfg_attr(feature = "std", serde(flatten))] - pub who_and_when: FlatWhoAndWhen, - - pub owner_id: AccountId, - - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] - pub parent_id: Option, - - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip", serialize_with = "bytes_to_string"))] - pub handle: Option>, - - #[cfg_attr(feature = "std", serde(flatten))] - pub content: FlatContent, - - #[cfg_attr(feature = "std", serde(skip_serializing_if = "ShouldSkip::should_skip"))] - pub is_hidden: Option, - - pub posts_count: u32, - pub hidden_posts_count: u32, - pub visible_posts_count: u32, - pub followers_count: u32, -} - -#[cfg(feature = "std")] -fn bytes_to_string(field: &Option>, serializer: S) -> Result where S: serde::Serializer { - let field_unwrapped = field.clone().unwrap_or_default(); - // If Bytes slice is invalid, then empty string will be returned - serializer.serialize_str( - std::str::from_utf8(&field_unwrapped).unwrap_or_default() - ) -} - -impl From> for FlatSpace { - fn from(from: Space) -> Self { - let Space { - id, created, updated, owner, - parent_id, handle, content, hidden, posts_count, - hidden_posts_count, followers_count, .. - } = from; - - Self { - id, - who_and_when: (created, updated).into(), - owner_id: owner, - parent_id, - handle, - content: content.into(), - is_hidden: bool_to_option(hidden), - posts_count, - hidden_posts_count, - visible_posts_count: posts_count.saturating_sub(hidden_posts_count), - followers_count, - } - } -} - -impl Module { - pub fn get_spaces_by_ids(space_ids: Vec) -> Vec> { - space_ids.iter() - .filter_map(|id| Self::require_space(*id).ok()) - .map(|space| space.into()) - .collect() - } - - fn get_spaces_slice) -> bool>( - start_id: u64, - limit: u64, - mut filter: F, - ) -> Vec> { - let mut space_id = start_id; - let mut spaces = Vec::new(); - - while spaces.len() < limit as usize && space_id >= FIRST_SPACE_ID { - if let Ok(space) = Self::require_space(space_id) { - if filter(&space) { - spaces.push(space.into()); - } - } - space_id = space_id.saturating_sub(1); - } - - spaces - } - - pub fn get_spaces(start_id: u64, limit: u64) -> Vec> { - Self::get_spaces_slice(start_id, limit, |_| true) - } - - pub fn get_public_spaces(start_id: u64, limit: u64) -> Vec> { - Self::get_spaces_slice(start_id, limit, |space| space.is_public()) - } - - pub fn get_unlisted_spaces(start_id: u64, limit: u64) -> Vec> { - Self::get_spaces_slice(start_id, limit, |space| space.is_unlisted()) - } - - pub fn get_space_id_by_handle(handle: Vec) -> Option { - Self::space_id_by_handle(handle) - } - - pub fn get_space_by_handle(handle: Vec) -> Option> { - Self::space_id_by_handle(handle) - .and_then(|space_id| Self::require_space(space_id).ok()) - .map(|space| space.into()) - } - - fn get_space_ids_by_owner) -> bool>(owner: T::AccountId, mut compare_fn: F) -> Vec { - Self::space_ids_by_owner(owner) - .iter() - .filter_map(|space_id| Self::require_space(*space_id).ok()) - .filter(|space| compare_fn(space)) - .map(|space| space.id) - .collect() - } - - pub fn get_public_space_ids_by_owner(owner: T::AccountId) -> Vec { - Self::get_space_ids_by_owner(owner, |space| !space.hidden) - } - - pub fn get_unlisted_space_ids_by_owner(owner: T::AccountId) -> Vec { - Self::get_space_ids_by_owner(owner, |space| space.hidden) - } - - pub fn get_next_space_id() -> SpaceId { - Self::next_space_id() - } -} \ No newline at end of file diff --git a/pallets/spaces/src/types.rs b/pallets/spaces/src/types.rs deleted file mode 100644 index a801b63..0000000 --- a/pallets/spaces/src/types.rs +++ /dev/null @@ -1,83 +0,0 @@ -use frame_support::pallet_prelude::*; - -use subsocial_support::{new_who_and_when, WhoAndWhenOf}; - -use super::*; - -pub const FIRST_SPACE_ID: u64 = 1; -pub const RESERVED_SPACE_COUNT: u64 = 1000; - -pub(crate) type SpacesByAccount = BoundedVec::MaxSpacesPerAccount>; - -/// Information about a space's owner, its' content, visibility and custom permissions. -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -#[scale_info(skip_type_params(T))] -pub struct Space { - /// Unique sequential identifier of a space. Examples of space ids: `1`, `2`, `3`, and so on. - pub id: SpaceId, - - pub created: WhoAndWhenOf, - /// True, if the content of this space was edited. - pub edited: bool, - - /// The current owner of a given space. - pub owner: T::AccountId, - - // The next fields can be updated by the owner: - pub content: Content, - - /// Hidden field is used to recommend to end clients (web and mobile apps) that a particular - /// space and its' posts should not be shown. - pub hidden: bool, - - /// This allows you to override Subsocial's default permissions by enabling or disabling role - /// permissions. - pub permissions: Option, -} - -#[derive(Encode, Decode, Clone, Eq, PartialEq, Default, RuntimeDebug, TypeInfo)] -pub struct SpaceUpdate { - pub content: Option, - pub hidden: Option, - pub permissions: Option>, -} - -impl Space { - pub fn new( - id: SpaceId, - created_by: T::AccountId, - content: Content, - permissions: Option, - ) -> Self { - Space { - id, - created: new_who_and_when::(created_by.clone()), - edited: false, - owner: created_by, - content, - hidden: false, - permissions, - } - } - - pub fn is_owner(&self, account: &T::AccountId) -> bool { - self.owner == *account - } - - pub fn is_follower(&self, account: &T::AccountId) -> bool { - T::SpaceFollows::is_space_follower(account.clone(), self.id) - } - - pub fn ensure_space_owner(&self, account: T::AccountId) -> DispatchResult { - ensure!(self.is_owner(&account), Error::::NotASpaceOwner); - Ok(()) - } - - pub fn is_public(&self) -> bool { - !self.hidden && self.content.is_some() - } - - pub fn is_unlisted(&self) -> bool { - !self.is_public() - } -} diff --git a/pallets/spaces/src/weights.rs b/pallets/spaces/src/weights.rs deleted file mode 100644 index a9f796b..0000000 --- a/pallets/spaces/src/weights.rs +++ /dev/null @@ -1,91 +0,0 @@ - -//! Autogenerated weights for pallet_spaces -//! -//! THIS FILE WAS AUTO-GENERATED USING THE SUBSTRATE BENCHMARK CLI VERSION 4.0.0-dev -//! DATE: 2023-02-15, STEPS: `50`, REPEAT: 20, LOW RANGE: `[]`, HIGH RANGE: `[]` -//! HOSTNAME: `benchmarks-ci`, CPU: `Intel(R) Xeon(R) Platinum 8280 CPU @ 2.70GHz` -//! EXECUTION: Some(Wasm), WASM-EXECUTION: Compiled, CHAIN: Some("dev"), DB CACHE: 1024 - -// Executed Command: - // ./scripts/../target/release/subsocial-collator - // benchmark - // pallet - // --chain - // dev - // --execution - // wasm - // --wasm-execution - // Compiled - // --pallet - // pallet_spaces - // --extrinsic - // * - // --steps - // 50 - // --repeat - // 20 - // --heap-pages - // 4096 - // --output - // pallets/spaces/src/weights.rs - // --template - // ./.maintain/weight-template.hbs - -#![cfg_attr(rustfmt, rustfmt_skip)] -#![allow(unused_parens)] -#![allow(unused_imports)] -#![allow(non_snake_case)] - -use frame_support::{traits::Get, weights::{Weight, constants::RocksDbWeight}}; -use sp_std::marker::PhantomData; - -/// Weight functions needed for pallet_spaces. -pub trait WeightInfo { - fn create_space() -> Weight; - fn update_space() -> Weight; -} - -/// Weights for pallet_spaces using the Substrate node and recommended hardware. -pub struct SubstrateWeight(PhantomData); - impl WeightInfo for SubstrateWeight { - // Storage: Spaces SpaceIdsByOwner (r:1 w:1) - // Storage: Spaces NextSpaceId (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) - // Storage: Spaces SpaceById (r:0 w:1) - fn create_space() -> Weight { - // Minimum execution time: 45_683 nanoseconds. - Weight::from_ref_time(46_598_000) - .saturating_add(T::DbWeight::get().reads(3)) - .saturating_add(T::DbWeight::get().writes(3)) - } - // Storage: Spaces SpaceById (r:1 w:1) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) - fn update_space() -> Weight { - // Minimum execution time: 52_466 nanoseconds. - Weight::from_ref_time(53_333_000) - .saturating_add(T::DbWeight::get().reads(2)) - .saturating_add(T::DbWeight::get().writes(1)) - } - } - - // For backwards compatibility and tests - impl WeightInfo for () { - // Storage: Spaces SpaceIdsByOwner (r:1 w:1) - // Storage: Spaces NextSpaceId (r:1 w:1) - // Storage: Timestamp Now (r:1 w:0) - // Storage: Spaces SpaceById (r:0 w:1) - fn create_space() -> Weight { - // Minimum execution time: 45_683 nanoseconds. - Weight::from_ref_time(46_598_000) - .saturating_add(RocksDbWeight::get().reads(3)) - .saturating_add(RocksDbWeight::get().writes(3)) - } - // Storage: Spaces SpaceById (r:1 w:1) - // Storage: SpaceFollows SpaceFollowedByAccount (r:1 w:0) - fn update_space() -> Weight { - // Minimum execution time: 52_466 nanoseconds. - Weight::from_ref_time(53_333_000) - .saturating_add(RocksDbWeight::get().reads(2)) - .saturating_add(RocksDbWeight::get().writes(1)) - } - } diff --git a/pallets/spaces/tests/Cargo.toml b/pallets/spaces/tests/Cargo.toml deleted file mode 100644 index fb8c394..0000000 --- a/pallets/spaces/tests/Cargo.toml +++ /dev/null @@ -1,58 +0,0 @@ -[package] -name = 'pallet-spaces-tests' -version = '0.1.7' -authors = ['DappForce '] -edition = '2021' -license = 'GPL-3.0-only' -homepage = 'https://subsocial.network' -repository = 'https://github.com/dappforce/subsocial-parachain' -description = 'Spaces pallet tests' -keywords = ['blockchain', 'cryptocurrency', 'social-network', 'news-feed', 'marketplace'] -categories = ['cryptography::cryptocurrencies'] - -[package.metadata.docs.rs] -targets = ["x86_64-unknown-linux-gnu"] - -[dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } - -# Local dependencies -subsocial-support = { default-features = false, path = '../../support' } -pallet-permissions = { default-features = false, path = '../../permissions' } - -# Substrate dependencies -pallet-timestamp = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-support = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -frame-system = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-runtime = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-std = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -pallet-spaces = { default-features = false, path = '..' } - -[dev-dependencies] -sp-core = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -sp-io = { git = 'https://github.com/paritytech/substrate', branch = 'polkadot-v0.9.37', default-features = false } -pallet-balances = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } -pallet-roles = { default-features = false, path = '../../roles' } -pallet-space-follows = { default-features = false, path = '../../space-follows' } -pallet-profiles = { default-features = false, path = '../../profiles' } -pallet-posts = { default-features = false, path = '../../posts' } - -[features] -default = ['std'] -std = [ - 'codec/std', - 'scale-info/std', - 'pallet-timestamp/std', - 'frame-support/std', - 'frame-system/std', - 'sp-runtime/std', - 'sp-std/std', - 'pallet-permissions/std', - 'pallet-balances/std', - 'pallet-roles/std', - 'pallet-space-follows/std', - 'pallet-profiles/std', - 'pallet-posts/std', -] -try-runtime = ["frame-support/try-runtime"] diff --git a/pallets/spaces/tests/src/lib.rs b/pallets/spaces/tests/src/lib.rs deleted file mode 100644 index 71dc193..0000000 --- a/pallets/spaces/tests/src/lib.rs +++ /dev/null @@ -1,6 +0,0 @@ -#[cfg(test)] -mod mock; -#[cfg(test)] -mod tests; -#[cfg(test)] -mod tests_utils; diff --git a/pallets/spaces/tests/src/mock.rs b/pallets/spaces/tests/src/mock.rs deleted file mode 100644 index 18acd38..0000000 --- a/pallets/spaces/tests/src/mock.rs +++ /dev/null @@ -1,144 +0,0 @@ -use frame_support::{pallet_prelude::ConstU32, parameter_types, traits::Everything}; -use sp_core::H256; -use sp_runtime::{ - testing::Header, - traits::{BlakeTwo256, IdentityLookup}, -}; -use sp_std::convert::{TryFrom, TryInto}; - -use crate::tests_utils::*; - -type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; -type Block = frame_system::mocking::MockBlock; - -frame_support::construct_runtime!( - pub enum Test where - Block = Block, - NodeBlock = Block, - UncheckedExtrinsic = UncheckedExtrinsic, - { - System: frame_system, - Timestamp: pallet_timestamp, - Balances: pallet_balances, - Permissions: pallet_permissions, - Roles: pallet_roles, - Profiles: pallet_profiles, - SpaceFollows: pallet_space_follows, - Posts: pallet_posts, - Spaces: pallet_spaces, - } -); - -pub(super) type AccountId = u64; -pub(super) type Balance = u64; -pub(super) type BlockNumber = u64; - -parameter_types! { - pub const BlockHashCount: u64 = 250; - pub const SS58Prefix: u8 = 42; -} - -impl frame_system::Config for Test { - type BaseCallFilter = Everything; - type BlockWeights = (); - type BlockLength = (); - type RuntimeOrigin = RuntimeOrigin; - type RuntimeCall = RuntimeCall; - type Index = u64; - type BlockNumber = BlockNumber; - type Hash = H256; - type Hashing = BlakeTwo256; - type AccountId = AccountId; - type Lookup = IdentityLookup; - type Header = Header; - type RuntimeEvent = RuntimeEvent; - type BlockHashCount = BlockHashCount; - type DbWeight = (); - type Version = (); - type PalletInfo = PalletInfo; - type AccountData = pallet_balances::AccountData; - type OnNewAccount = (); - type OnKilledAccount = (); - type SystemWeightInfo = (); - type SS58Prefix = SS58Prefix; - type OnSetCode = (); - type MaxConsumers = frame_support::traits::ConstU32<16>; -} - -parameter_types! { - pub const MinimumPeriod: u64 = 5; -} - -impl pallet_timestamp::Config for Test { - type Moment = u64; - type OnTimestampSet = (); - type MinimumPeriod = MinimumPeriod; - type WeightInfo = (); -} - -parameter_types! { - pub const ExistentialDeposit: u64 = 1; -} - -impl pallet_balances::Config for Test { - type Balance = Balance; - type DustRemoval = (); - type RuntimeEvent = RuntimeEvent; - type ExistentialDeposit = ExistentialDeposit; - type AccountStore = System; - type WeightInfo = (); - type MaxLocks = (); - type MaxReserves = (); - type ReserveIdentifier = (); -} - -parameter_types! { - pub const MaxCommentDepth: u32 = 10; -} - -impl pallet_posts::Config for Test { - type RuntimeEvent = RuntimeEvent; - type MaxCommentDepth = MaxCommentDepth; - type IsPostBlocked = MockModeration; - type WeightInfo = (); -} - -impl pallet_permissions::Config for Test { - type DefaultSpacePermissions = pallet_permissions::default_permissions::DefaultSpacePermissions; -} - -parameter_types! { - pub const MaxUsersToProcessPerDeleteRole: u16 = 40; -} - -impl pallet_roles::Config for Test { - type RuntimeEvent = RuntimeEvent; - type MaxUsersToProcessPerDeleteRole = MaxUsersToProcessPerDeleteRole; - type SpacePermissionsProvider = Spaces; - type SpaceFollows = SpaceFollows; - type IsAccountBlocked = MockModeration; - type IsContentBlocked = MockModeration; - type WeightInfo = (); -} - -impl pallet_profiles::Config for Test { - type RuntimeEvent = RuntimeEvent; - type SpacePermissionsProvider = Spaces; - type SpacesInterface = Spaces; - type WeightInfo = (); -} - -impl pallet_spaces::Config for Test { - type RuntimeEvent = RuntimeEvent; - type Roles = Roles; - type SpaceFollows = SpaceFollows; - type IsAccountBlocked = MockModeration; - type IsContentBlocked = MockModeration; - type MaxSpacesPerAccount = ConstU32<100>; - type WeightInfo = (); -} - -impl pallet_space_follows::Config for Test { - type RuntimeEvent = RuntimeEvent; - type WeightInfo = (); -} diff --git a/pallets/spaces/tests/src/tests.rs b/pallets/spaces/tests/src/tests.rs deleted file mode 100644 index ca4c76f..0000000 --- a/pallets/spaces/tests/src/tests.rs +++ /dev/null @@ -1,345 +0,0 @@ -use frame_support::{assert_noop, assert_ok}; - -use pallet_permissions::SpacePermission as SP; -use pallet_spaces::Error as SpacesError; -use subsocial_support::{mock_functions::*, ContentError, ModerationError}; - -use crate::{mock::*, tests_utils::*}; - -#[test] -fn update_space_should_fail_when_account_is_blocked() { - ExtBuilder::build_with_space().execute_with(|| { - block_account_in_space_1(); - assert_noop!( - _update_space(None, None, Some(update_for_space_content(updated_space_content()))), - ModerationError::AccountIsBlocked, - ); - }); -} - -#[test] -fn update_space_should_fail_when_content_is_blocked() { - ExtBuilder::build_with_space().execute_with(|| { - block_content_in_space_1(); - assert_noop!( - _update_space(None, None, Some(space_update(Some(valid_content_ipfs()), None))), - ModerationError::ContentIsBlocked, - ); - }); -} - -#[test] -fn create_space_should_work() { - ExtBuilder::build().execute_with(|| { - assert_ok!(_create_default_space()); // SpaceId 1 - - // Check storages - assert_eq!(Spaces::space_ids_by_owner(ACCOUNT1), vec![SPACE1]); - assert_eq!(Spaces::next_space_id(), SPACE2); - - // Check whether data stored correctly - let space = Spaces::space_by_id(SPACE1).unwrap(); - - assert_eq!(space.created.account, ACCOUNT1); - assert!(!space.edited); - assert!(!space.hidden); - - assert_eq!(space.owner, ACCOUNT1); - assert_eq!(space.content, space_content_ipfs()); - }); -} - -#[test] -fn create_space_should_work_with_permissions_override() { - let perms = permissions_where_everyone_can_create_post(); - ExtBuilder::build_with_space_and_custom_permissions(perms.clone()).execute_with(|| { - let space = Spaces::space_by_id(SPACE1).unwrap(); - assert_eq!(space.permissions, Some(perms)); - }); -} - -#[test] -fn create_post_should_work_overridden_space_permission_for_everyone() { - ExtBuilder::build_with_space_and_custom_permissions( - permissions_where_everyone_can_create_post(), - ) - .execute_with(|| { - assert_ok!(_create_post(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None, None)); - }); -} - -#[test] -fn create_post_should_work_overridden_space_permission_for_followers() { - ExtBuilder::build_with_space_and_custom_permissions( - permissions_where_follower_can_create_post(), - ) - .execute_with(|| { - assert_ok!(_default_follow_space()); - - assert_ok!(_create_post(Some(RuntimeOrigin::signed(ACCOUNT2)), None, None, None)); - }); -} - -#[test] -fn create_space_should_fail_when_ipfs_cid_is_invalid() { - ExtBuilder::build().execute_with(|| { - // Try to catch an error creating a space with invalid content - assert_noop!( - _create_space(None, Some(invalid_content_ipfs()), None), - ContentError::InvalidIpfsCid, - ); - }); -} - -#[test] -fn update_space_should_work() { - ExtBuilder::build_with_space().execute_with(|| { - let expected_content_ipfs = updated_space_content(); - // Space update with ID 1 should be fine - - assert_ok!(_update_space( - None, // From ACCOUNT1 (has permission as he's an owner) - None, - Some(space_update(Some(expected_content_ipfs.clone()), Some(true),)) - )); - - // Check whether space updates correctly - let space = Spaces::space_by_id(SPACE1).unwrap(); - assert_eq!(space.content, expected_content_ipfs); - assert!(space.hidden); - }); -} - -#[test] -fn update_space_should_work_when_one_of_roles_is_permitted() { - ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::UpdateSpace]).execute_with( - || { - let space_update = space_update(Some(updated_space_content()), Some(true)); - - assert_ok!(_update_space( - Some(RuntimeOrigin::signed(ACCOUNT2)), - Some(SPACE1), - Some(space_update) - )); - }, - ); -} - -#[test] -fn update_space_should_fail_when_no_updates_for_space_provided() { - ExtBuilder::build_with_space().execute_with(|| { - // Try to catch an error updating a space with no changes - assert_noop!(_update_space(None, None, None), SpacesError::::NoUpdatesForSpace); - }); -} - -#[test] -fn update_space_should_fail_when_space_not_found() { - ExtBuilder::build_with_space().execute_with(|| { - // Try to catch an error updating a space with wrong space ID - assert_noop!( - _update_space( - None, - Some(SPACE2), - Some(update_for_space_content(updated_space_content())) - ), - SpacesError::::SpaceNotFound - ); - }); -} - -#[test] -fn update_space_should_fail_when_account_has_no_permission_to_update_space() { - ExtBuilder::build_with_space().execute_with(|| { - // Try to catch an error updating a space with an account that it not permitted - assert_noop!( - _update_space( - Some(RuntimeOrigin::signed(ACCOUNT2)), - None, - Some(update_for_space_content(updated_space_content())) - ), - SpacesError::::NoPermissionToUpdateSpace - ); - }); -} - -#[test] -fn update_space_should_fail_when_ipfs_cid_is_invalid() { - ExtBuilder::build_with_space().execute_with(|| { - // Try to catch an error updating a space with invalid content - assert_noop!( - _update_space(None, None, Some(space_update(Some(invalid_content_ipfs()), None,))), - ContentError::InvalidIpfsCid, - ); - }); -} - -#[test] -fn update_space_should_fail_when_no_right_permission_in_account_roles() { - ExtBuilder::build_with_a_few_roles_granted_to_account2(vec![SP::UpdateSpace]).execute_with( - || { - let space_update = space_update(Some(updated_space_content()), Some(true)); - - assert_ok!(_delete_default_role()); - - assert_noop!( - _update_space(Some(RuntimeOrigin::signed(ACCOUNT2)), Some(SPACE1), Some(space_update)), - SpacesError::::NoPermissionToUpdateSpace - ); - }, - ); -} - -// TODO: refactor or remove. Deprecated tests -// Find public space ids tests -// -------------------------------------------------------------------------------------------- -/*#[test] -fn find_public_space_ids_should_work() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!(_create_space(None, None, Some(Some(space_handle1())), None, None)); - - let space_ids = Spaces::find_public_space_ids(0, 3); - assert_eq!(space_ids, vec![SPACE1, SPACE2]); - }); -} - -#[test] -fn find_public_space_ids_should_work_with_zero_offset() { - ExtBuilder::build_with_space().execute_with(|| { - let space_ids = Spaces::find_public_space_ids(0, 1); - assert_eq!(space_ids, vec![SPACE1]); - }); -} - -#[test] -fn find_public_space_ids_should_work_with_zero_limit() { - ExtBuilder::build_with_space().execute_with(|| { - let space_ids = Spaces::find_public_space_ids(1, 0); - assert_eq!(space_ids, vec![SPACE1]); - }); -} - -#[test] -fn find_public_space_ids_should_work_with_zero_offset_and_zero_limit() { - ExtBuilder::build_with_space().execute_with(|| { - let space_ids = Spaces::find_public_space_ids(0, 0); - assert_eq!(space_ids, vec![]); - }); -} - -// Find unlisted space ids tests -// -------------------------------------------------------------------------------------------- - -#[test] -fn find_unlisted_space_ids_should_work() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!(_create_space(None, None, Some(Some(space_handle1())), None, None)); - assert_ok!( - _update_space( - None, - Some(SPACE1), - Some( - space_update( - None, - None, - Some(Content::None), - Some(true), - None - ) - ) - ) - ); - - assert_ok!( - _update_space( - None, - Some(SPACE2), - Some( - space_update( - None, - None, - Some(Content::None), - Some(true), - None - ) - ) - ) - ); - - - let space_ids = Spaces::find_unlisted_space_ids(0, 2); - assert_eq!(space_ids, vec![SPACE1, SPACE2]); - }); -} - -#[test] -fn find_unlisted_space_ids_should_work_with_zero_offset() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!( - _update_space( - None, - Some(SPACE1), - Some( - space_update( - None, - None, - Some(Content::None), - Some(true), - None - ) - ) - ) - ); - - let space_ids = Spaces::find_unlisted_space_ids(0, 1); - assert_eq!(space_ids, vec![SPACE1]); - }); -} - -#[test] -fn find_unlisted_space_ids_should_work_with_zero_limit() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!( - _update_space( - None, - Some(SPACE1), - Some( - space_update( - None, - None, - Some(Content::None), - Some(true), - None - ) - ) - ) - ); - - let space_ids = Spaces::find_unlisted_space_ids(1, 0); - assert_eq!(space_ids, vec![]); - }); -} - -#[test] -fn find_unlisted_space_ids_should_work_with_zero_offset_and_zero_limit() { - ExtBuilder::build_with_space().execute_with(|| { - assert_ok!( - _update_space( - None, - Some(SPACE1), - Some( - space_update( - None, - None, - Some(Content::None), - Some(true), - None - ) - ) - ) - ); - - let space_ids = Spaces::find_unlisted_space_ids(0, 0); - assert_eq!(space_ids, vec![]); - }); -}*/ diff --git a/pallets/spaces/tests/src/tests_utils.rs b/pallets/spaces/tests/src/tests_utils.rs deleted file mode 100644 index 4b483b5..0000000 --- a/pallets/spaces/tests/src/tests_utils.rs +++ /dev/null @@ -1,396 +0,0 @@ -use std::{ - cell::RefCell, - collections::HashMap, - hash::{Hash, Hasher}, -}; - -use frame_support::{assert_ok, pallet_prelude::*}; -use sp_core::storage::Storage; -use sp_io::TestExternalities; - -use pallet_permissions::{ - default_permissions::DefaultSpacePermissions, SpacePermission as SP, SpacePermission, - SpacePermissions, -}; -use pallet_posts::PostExtension; -use pallet_spaces::types::SpaceUpdate; -use subsocial_support::{ - mock_functions::valid_content_ipfs, - traits::{IsAccountBlocked, IsContentBlocked, IsPostBlocked, IsSpaceBlocked}, - Content, PostId, SpaceId, User, -}; - -use crate::mock::*; - -////// Ext Builder - -pub struct ExtBuilder; - -impl ExtBuilder { - fn configure_storages(storage: &mut Storage) { - let mut accounts = Vec::new(); - for account in ACCOUNT1..=ACCOUNT3 { - accounts.push(account); - } - - let _ = pallet_balances::GenesisConfig:: { - balances: accounts.iter().cloned().map(|k| (k, 100)).collect(), - } - .assimilate_storage(storage); - } - - /// Default ext configuration with BlockNumber 1 - pub fn build() -> TestExternalities { - let mut storage = frame_system::GenesisConfig::default().build_storage::().unwrap(); - - Self::configure_storages(&mut storage); - - let mut ext = TestExternalities::from(storage); - ext.execute_with(|| System::set_block_number(1)); - - ext - } - - fn add_default_space() { - assert_ok!(_create_default_space()); - } - - fn add_space_with_custom_permissions(permissions: SpacePermissions) { - assert_ok!(_create_space(None, None, Some(Some(permissions)))); - } - - /// Custom ext configuration with SpaceId 1 and BlockNumber 1 - pub fn build_with_space() -> TestExternalities { - let mut ext = Self::build(); - ext.execute_with(Self::add_default_space); - ext - } - - /// Custom ext configuration with specified permissions granted (includes SpaceId 1) - pub fn build_with_a_few_roles_granted_to_account2(perms: Vec) -> TestExternalities { - let mut ext = Self::build_with_space(); - - ext.execute_with(|| { - let user = User::Account(ACCOUNT2); - assert_ok!(_create_default_role_with_permissions(perms)); // RoleId 1 - assert_ok!(_create_default_role()); // RoleId 2 - - assert_ok!(_grant_role(None, Some(ROLE1), Some(vec![user.clone()]))); - assert_ok!(_grant_role(None, Some(ROLE2), Some(vec![user]))); - }); - - ext - } - - /// Custom ext configuration with a space and override the space permissions - pub fn build_with_space_and_custom_permissions( - permissions: SpacePermissions, - ) -> TestExternalities { - let mut ext = Self::build(); - ext.execute_with(|| Self::add_space_with_custom_permissions(permissions)); - ext - } -} - -////// Consts - -pub(crate) const ACCOUNT1: AccountId = 1; -pub(crate) const ACCOUNT2: AccountId = 2; -pub(crate) const ACCOUNT3: AccountId = 3; - -pub(crate) const SPACE1: SpaceId = 1001; -pub(crate) const SPACE2: SpaceId = 1002; - -type RoleId = u64; - -pub(crate) const ROLE1: RoleId = 1; -pub(crate) const ROLE2: RoleId = 2; - -////// Moderation Utils - -// Moderation pallet mocks - -/* ------------------------------------------------------------------------------------------------ */ -// Moderation tests - -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug)] -pub enum EntityId { - Content(Content), - Account(AccountId), - Space(SpaceId), - Post(PostId), -} - -impl Hash for EntityId { - fn hash(&self, state: &mut H) { - match self { - EntityId::Content(content) => match content { - Content::None => 0.hash(state), - Content::Other(content) => content.hash(state), - Content::IPFS(content) => content.hash(state), - }, - EntityId::Account(account) => account.hash(state), - EntityId::Space(space) => space.hash(state), - EntityId::Post(post) => post.hash(state), - } - } -} - -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, Hash)] -pub enum EntityStatus { - Allowed, - Blocked, -} - -thread_local! { - pub static MOCK_MODERATION_STATE: RefCell> = RefCell::new(Default::default()); -} -pub struct MockModeration; - -impl MockModeration { - fn set_entity_status(entity: EntityId, space: SpaceId, status: EntityStatus) { - MOCK_MODERATION_STATE.with(|mock_moderation_state| { - let mut mock_moderation_state = mock_moderation_state.borrow_mut(); - mock_moderation_state.insert((entity, space), status); - }); - } - - fn get_entity_status(id: EntityId, scope: SpaceId) -> Option { - MOCK_MODERATION_STATE.with(|mock_moderation_state| { - let mock_moderation_state = mock_moderation_state.borrow(); - let status = mock_moderation_state.get(&(id, scope)).cloned(); - status - }) - } - - fn is_allowed_entity(id: EntityId, scope: SpaceId) -> bool { - Self::get_entity_status(id, scope).unwrap_or(EntityStatus::Allowed) == EntityStatus::Allowed - } - - fn is_blocked_entity(id: EntityId, scope: SpaceId) -> bool { - Self::get_entity_status(id, scope) == Some(EntityStatus::Blocked) - } -} - -impl IsPostBlocked for MockModeration { - fn is_blocked_post(post_id: PostId, scope: SpaceId) -> bool { - Self::is_blocked_entity(EntityId::Post(post_id), scope) - } - - fn is_allowed_post(post_id: PostId, scope: SpaceId) -> bool { - Self::is_allowed_entity(EntityId::Post(post_id), scope) - } -} - -impl IsAccountBlocked for MockModeration { - fn is_blocked_account(account: AccountId, scope: SpaceId) -> bool { - Self::is_blocked_entity(EntityId::Account(account), scope) - } - - fn is_allowed_account(account: AccountId, scope: SpaceId) -> bool { - Self::is_allowed_entity(EntityId::Account(account), scope) - } -} - -impl IsSpaceBlocked for MockModeration { - fn is_blocked_space(space_id: SpaceId, scope: SpaceId) -> bool { - Self::is_blocked_entity(EntityId::Space(space_id), scope) - } - - fn is_allowed_space(space_id: SpaceId, scope: SpaceId) -> bool { - Self::is_allowed_entity(EntityId::Space(space_id), scope) - } -} - -impl IsContentBlocked for MockModeration { - fn is_blocked_content(content: Content, scope: SpaceId) -> bool { - Self::is_blocked_entity(EntityId::Content(content), scope) - } - - fn is_allowed_content(content: Content, scope: SpaceId) -> bool { - Self::is_allowed_entity(EntityId::Content(content), scope) - } -} - -pub(crate) fn block_account_in_space_1() { - MockModeration::set_entity_status(EntityId::Account(ACCOUNT1), SPACE1, EntityStatus::Blocked); -} - -pub(crate) fn block_content_in_space_1() { - MockModeration::set_entity_status( - EntityId::Content(valid_content_ipfs()), - SPACE1, - EntityStatus::Blocked, - ); -} - -///////////// Space Utils - -pub(crate) fn space_content_ipfs() -> Content { - Content::IPFS(b"bafyreib3mgbou4xln42qqcgj6qlt3cif35x4ribisxgq7unhpun525l54e".to_vec()) -} - -pub(crate) fn updated_space_content() -> Content { - Content::IPFS(b"QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW2CuDgwxkD4".to_vec()) -} - -pub(crate) fn update_for_space_content(new_content: Content) -> SpaceUpdate { - space_update(Some(new_content), None) -} - -pub(crate) fn space_update(content: Option, hidden: Option) -> SpaceUpdate { - SpaceUpdate { content, hidden, permissions: None } -} - -pub(crate) fn _create_default_space() -> DispatchResult { - _create_space(None, None, None) -} - -pub(crate) fn _create_space( - origin: Option, - content: Option, - permissions: Option>, -) -> DispatchResult { - Spaces::create_space( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - content.unwrap_or_else(space_content_ipfs), - permissions.unwrap_or_default(), - ) -} - -pub(crate) fn _create_space_with_content(content: Content) -> DispatchResult { - _create_space(None, Some(content), None) -} - -pub(crate) fn _update_space( - origin: Option, - space_id: Option, - update: Option, -) -> DispatchResult { - Spaces::update_space( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - space_id.unwrap_or(SPACE1), - update.unwrap_or_else(|| space_update(None, None)), - ) -} - -///////////// Post Utils - -pub(crate) fn post_content_ipfs() -> Content { - Content::IPFS(b"bafyreidzue2dtxpj6n4x5mktrt7las5wz5diqma47zr25uau743dhe76we".to_vec()) -} - -pub(crate) fn extension_regular_post() -> PostExtension { - PostExtension::RegularPost -} - -pub(crate) fn _create_default_post() -> DispatchResult { - _create_post(None, None, None, None) -} - -pub(crate) fn _create_post( - origin: Option, - space_id_opt: Option>, - extension: Option, - content: Option, -) -> DispatchResult { - Posts::create_post( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - space_id_opt.unwrap_or(Some(SPACE1)), - extension.unwrap_or_else(extension_regular_post), - content.unwrap_or_else(post_content_ipfs), - ) -} - -//// Space follows utils - -pub(crate) fn _default_follow_space() -> DispatchResult { - _follow_space(None, None) -} - -pub(crate) fn _follow_space(origin: Option, space_id: Option) -> DispatchResult { - SpaceFollows::follow_space( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT2)), - space_id.unwrap_or(SPACE1), - ) -} - -/////// Roles utils - -pub(crate) fn default_role_content_ipfs() -> Content { - Content::IPFS(b"QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD4".to_vec()) -} - -pub(crate) fn _create_default_role() -> DispatchResult { - _create_role(None, None, None, None, None) -} - -pub(crate) fn _create_role( - origin: Option, - space_id: Option, - time_to_live: Option>, - content: Option, - permissions: Option>, -) -> DispatchResult { - // TODO: remove - Roles::create_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - space_id.unwrap_or(SPACE1), - time_to_live.unwrap_or_default(), // Should return 'None' - content.unwrap_or_else(default_role_content_ipfs), - permissions.unwrap_or_else(permission_set_default), - ) -} - -pub(crate) fn _create_default_role_with_permissions(permissions: Vec) -> DispatchResult { - _create_role(None, None, None, None, Some(permissions)) -} - -pub(crate) fn _grant_role( - origin: Option, - role_id: Option, - users: Option>>, -) -> DispatchResult { - Roles::grant_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - role_id.unwrap_or(ROLE1), - users.unwrap_or_else(|| vec![User::Account(ACCOUNT2)]), - ) -} - -pub(crate) fn _delete_default_role() -> DispatchResult { - _delete_role(None, None) -} - -pub(crate) fn _delete_role(origin: Option, role_id: Option) -> DispatchResult { - let users_count = Roles::users_by_role_id(role_id.unwrap_or(ROLE1)).len(); - Roles::delete_role( - origin.unwrap_or_else(|| RuntimeOrigin::signed(ACCOUNT1)), - role_id.unwrap_or(ROLE1), - users_count as u32, - ) -} - -/////// Permissions utils - -pub(crate) fn permissions_where_everyone_can_create_post() -> SpacePermissions { - let mut default_permissions = DefaultSpacePermissions::get(); - default_permissions.everyone = default_permissions.everyone.map(|mut permissions| { - permissions.insert(SP::CreatePosts); - permissions - }); - - default_permissions -} - -pub(crate) fn permissions_where_follower_can_create_post() -> SpacePermissions { - let mut default_permissions = DefaultSpacePermissions::get(); - default_permissions.follower = Some(vec![SP::CreatePosts].into_iter().collect()); - - default_permissions -} - -/// Permissions Set that includes next permission: ManageRoles -pub(crate) fn permission_set_default() -> Vec { - vec![SP::ManageRoles] -} diff --git a/pallets/support/Cargo.toml b/pallets/support/Cargo.toml deleted file mode 100644 index d28c46d..0000000 --- a/pallets/support/Cargo.toml +++ /dev/null @@ -1,35 +0,0 @@ -[package] -name = "subsocial-support" -version = "0.1.7" -authors = ["DappForce "] -edition = "2021" -license = "GPL-3.0-only" -homepage = "https://subsocial.network" -repository = "https://github.com/dappforce/subsocial-parachain" -description = "Pallet with common utils for the parachain node" -keywords = ["blockchain", "cryptocurrency", "social-network", "news-feed", "marketplace"] -categories = ["cryptography::cryptocurrencies"] - -[features] -default = ["std"] -std = [ - "strum/std", - "codec/std", - "scale-info/std", - "frame-support/std", - "frame-system/std", - "pallet-timestamp/std", - "sp-std/std", -] - -[dependencies] -strum = { version = "0.24", default-features = false, features = ["derive"] } - -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } -scale-info = { version = "2.2.0", default-features = false, features = ["derive"] } - -# Substrate dependencies -frame-support = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } -frame-system = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } -pallet-timestamp = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } -sp-std = { git = "https://github.com/paritytech/substrate", branch = "polkadot-v0.9.37", default-features = false } diff --git a/pallets/support/src/lib.rs b/pallets/support/src/lib.rs deleted file mode 100644 index 8e9b7df..0000000 --- a/pallets/support/src/lib.rs +++ /dev/null @@ -1,256 +0,0 @@ -// TODO Try to reuse these utility functions via crate in the future, -// when solochain and parachain will use the same substrate version. - -#![cfg_attr(not(feature = "std"), no_std)] - -use codec::{Decode, Encode}; -use scale_info::TypeInfo; - -use frame_support::pallet_prelude::*; -use sp_std::{collections::btree_set::BTreeSet, vec, vec::Vec}; - -pub mod traits; - -pub type SpaceId = u64; -pub type PostId = u64; - -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -pub struct WhoAndWhen { - pub account: AccountId, - pub block: BlockNumber, - pub time: Moment, -} - -pub type WhoAndWhenOf = WhoAndWhen< - ::AccountId, - ::BlockNumber, - ::Moment, ->; - -pub fn new_who_and_when( - account: T::AccountId, -) -> WhoAndWhen -where - T: frame_system::Config + pallet_timestamp::Config, -{ - WhoAndWhen { - account, - block: frame_system::Pallet::::block_number(), - time: pallet_timestamp::Pallet::::now(), - } -} - -#[derive(Encode, Decode, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -pub enum Content { - /// No content. - None, - /// A raw vector of bytes. - Other(Vec), - /// IPFS CID v0 of content. - IPFS(Vec), -} - -impl From for Vec { - fn from(content: Content) -> Vec { - match content { - Content::None => vec![], - Content::Other(vec_u8) => vec_u8, - Content::IPFS(vec_u8) => vec_u8, - } - } -} - -impl Default for Content { - fn default() -> Self { - Self::None - } -} - -impl Content { - pub fn is_none(&self) -> bool { - self == &Self::None - } - - pub fn is_some(&self) -> bool { - !self.is_none() - } - - pub fn is_ipfs(&self) -> bool { - matches!(self, Self::IPFS(_)) - } -} - -#[derive(Encode, Decode, Ord, PartialOrd, Clone, Eq, PartialEq, RuntimeDebug, TypeInfo)] -pub enum User { - Account(AccountId), - Space(SpaceId), -} - -impl User { - pub fn maybe_account(self) -> Option { - if let User::Account(account_id) = self { - Some(account_id) - } else { - None - } - } - - pub fn maybe_space(self) -> Option { - if let User::Space(space_id) = self { - Some(space_id) - } else { - None - } - } -} - -pub fn convert_users_vec_to_btree_set( - users_vec: Vec>, -) -> Result>, DispatchError> { - let mut users_set: BTreeSet> = BTreeSet::new(); - - for user in users_vec.iter() { - users_set.insert(user.clone()); - } - - Ok(users_set) -} - -#[derive(Encode, Decode, RuntimeDebug, strum::IntoStaticStr)] -pub enum ModerationError { - /// Account is blocked in a given space. - AccountIsBlocked, - /// Content is blocked in a given space. - ContentIsBlocked, - /// Post is blocked in a given space. - PostIsBlocked, - /// Space handle is too short. - HandleIsTooShort, - /// Space handle is too long. - HandleIsTooLong, - /// Space handle contains invalid characters. - HandleContainsInvalidChars, -} - -impl From for DispatchError { - fn from(err: ModerationError) -> DispatchError { - Self::Other(err.into()) - } -} - -#[derive(Encode, Decode, RuntimeDebug, strum::IntoStaticStr)] -pub enum ContentError { - /// IPFS CID is invalid. - InvalidIpfsCid, - /// `Other` content type is not yet supported. - OtherContentTypeNotSupported, - /// Content type is `None`. - ContentIsEmpty, -} - -impl From for DispatchError { - fn from(err: ContentError) -> DispatchError { - Self::Other(err.into()) - } -} - -/// Minimal set of fields from Space struct that are required by roles pallet. -pub struct SpacePermissionsInfo { - pub owner: AccountId, - pub permissions: Option, -} - -pub fn ensure_content_is_valid(content: Content) -> DispatchResult { - match content { - Content::None => Ok(()), - Content::Other(_) => Err(ContentError::OtherContentTypeNotSupported.into()), - Content::IPFS(ipfs_cid) => { - let len = ipfs_cid.len(); - // IPFS CID v0 is 46 bytes. - // IPFS CID v1 is 59 bytes. - ensure!(len == 46 || len == 59, ContentError::InvalidIpfsCid); - Ok(()) - }, - } -} - -/// Ensure that a given content is not `None`. -pub fn ensure_content_is_some(content: &Content) -> DispatchResult { - ensure!(content.is_some(), ContentError::ContentIsEmpty); - Ok(()) -} - -pub fn remove_from_vec(vector: &mut Vec, element: F) { - if let Some(index) = vector.iter().position(|x| *x == element) { - vector.swap_remove(index); - } -} - -pub fn remove_from_bounded_vec(vector: &mut BoundedVec, element: F) { - if let Some(index) = vector.iter().position(|x| *x == element) { - vector.swap_remove(index); - } -} - -pub fn bool_to_option(value: bool) -> Option { - if value { - Some(value) - } else { - None - } -} - -pub mod mock_functions { - use super::Content; - - pub fn valid_content_ipfs() -> Content { - Content::IPFS(b"QmRAQB6YaCaidP37UdDnjFY5aQuiBrbqdyoW1CaDgwxkD4".to_vec()) - } - - pub fn another_valid_content_ipfs() -> Content { - // Only the last character is changed, only for testing purposes. - Content::IPFS(b"QmRAQB6YaCaidP37UdDnjFY5aQuiBrbqdyoW1CaDgwxkD5".to_vec()) - } - - pub fn invalid_content_ipfs() -> Content { - Content::IPFS(b"QmRAQB6DaazhR8".to_vec()) - } -} - -#[cfg(test)] -mod tests { - use super::remove_from_vec; - - #[test] - fn remove_from_vec_should_work_with_zero_elements() { - let element: u16 = 2; - let vector: &mut Vec = &mut vec![]; - - remove_from_vec(vector, element); - assert!(vector.is_empty()); - } - - #[test] - fn remove_from_vec_should_work_with_last_element() { - let element: u16 = 2; - let vector: &mut Vec = &mut vec![6, 2]; - - vector.remove(0); - assert_eq!(vector, &mut vec![2]); - - remove_from_vec(vector, element); - assert!(vector.is_empty()); - } - - #[test] - fn remove_from_vec_should_work_with_two_elements() { - let element: u16 = 2; - let vector: &mut Vec = &mut vec![6, 2, 7]; - - vector.remove(0); - assert_eq!(vector, &mut vec![2, 7]); - - remove_from_vec(vector, element); - assert_eq!(vector, &mut vec![7]); - } -} diff --git a/pallets/support/src/traits.rs b/pallets/support/src/traits.rs deleted file mode 100644 index 04a08a5..0000000 --- a/pallets/support/src/traits.rs +++ /dev/null @@ -1,7 +0,0 @@ -pub use common::{ - ProfileManager, SpaceFollowsProvider, SpacePermissionsProvider, SpacesInterface, -}; -pub use moderation::{IsAccountBlocked, IsContentBlocked, IsPostBlocked, IsSpaceBlocked}; - -mod common; -mod moderation; diff --git a/pallets/support/src/traits/common.rs b/pallets/support/src/traits/common.rs deleted file mode 100644 index fccc185..0000000 --- a/pallets/support/src/traits/common.rs +++ /dev/null @@ -1,27 +0,0 @@ -#![cfg_attr(not(feature = "std"), no_std)] - -use frame_support::dispatch::{DispatchError, DispatchResult}; - -use crate::{Content, SpaceId}; - -pub trait SpacePermissionsProvider { - fn space_permissions_info(id: SpaceId) -> Result; - - fn ensure_space_owner(id: SpaceId, account: &AccountId) -> DispatchResult; -} - -pub trait SpaceFollowsProvider { - type AccountId; - - fn is_space_follower(account: Self::AccountId, space_id: SpaceId) -> bool; -} - -pub trait ProfileManager { - fn unlink_space_from_profile(account: &AccountId, space_id: SpaceId); -} - -pub trait SpacesInterface { - fn get_space_owner(space_id: SpaceId) -> Result; - - fn create_space(owner: &AccountId, content: Content) -> Result; -} diff --git a/pallets/support/src/traits/moderation.rs b/pallets/support/src/traits/moderation.rs deleted file mode 100644 index c2ef620..0000000 --- a/pallets/support/src/traits/moderation.rs +++ /dev/null @@ -1,51 +0,0 @@ -use crate::{Content, SpaceId}; - -pub trait IsAccountBlocked { - fn is_blocked_account(account: AccountId, scope: SpaceId) -> bool; - fn is_allowed_account(account: AccountId, scope: SpaceId) -> bool; -} - -impl IsAccountBlocked for () { - fn is_blocked_account(_account: AccountId, _scope: u64) -> bool { - false - } - - fn is_allowed_account(_account: AccountId, _scope: u64) -> bool { - true - } -} - -pub trait IsSpaceBlocked { - fn is_blocked_space(space_id: SpaceId, scope: SpaceId) -> bool; - fn is_allowed_space(space_id: SpaceId, scope: SpaceId) -> bool; -} - -// TODO: reuse `type PostId` from pallet_utils in future updates -pub trait IsPostBlocked { - fn is_blocked_post(post_id: PostId, scope: SpaceId) -> bool; - fn is_allowed_post(post_id: PostId, scope: SpaceId) -> bool; -} - -impl IsPostBlocked for () { - fn is_blocked_post(_post_id: PostId, _scope: SpaceId) -> bool { - false - } - - fn is_allowed_post(_post_id: PostId, _scope: u64) -> bool { - true - } -} - -pub trait IsContentBlocked { - fn is_blocked_content(content: Content, scope: SpaceId) -> bool; - fn is_allowed_content(content: Content, scope: SpaceId) -> bool; -} - -impl IsContentBlocked for () { - fn is_blocked_content(_content: Content, _scope: u64) -> bool { - false - } - fn is_allowed_content(_content: Content, _scope: SpaceId) -> bool { - true - } -} diff --git a/pallets/template/Cargo.toml b/pallets/template/Cargo.toml deleted file mode 100644 index 80a7865..0000000 --- a/pallets/template/Cargo.toml +++ /dev/null @@ -1,39 +0,0 @@ -[package] -name = "pallet-template" -version = "4.0.0-dev" -description = "FRAME pallet template for defining custom runtime logic." -authors = ["Substrate DevHub "] -homepage = "https://substrate.io" -edition = "2021" -license = "Unlicense" -publish = false -repository = "https://github.com/substrate-developer-hub/substrate-node-template/" - -[package.metadata.docs.rs] -targets = ["x86_64-unknown-linux-gnu"] - -[dependencies] -codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = [ - "derive", -] } -scale-info = { version = "2.1.1", default-features = false, features = ["derive"] } -frame-benchmarking = { version = "4.0.0-dev", default-features = false, optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -frame-support = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -frame-system = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } - -[dev-dependencies] -sp-core = { version = "7.0.0", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-io = { version = "7.0.0", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-runtime = { version = "7.0.0", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } - -[features] -default = ["std"] -std = [ - "codec/std", - "frame-benchmarking?/std", - "frame-support/std", - "frame-system/std", - "scale-info/std", -] -runtime-benchmarks = ["frame-benchmarking/runtime-benchmarks"] -try-runtime = ["frame-support/try-runtime"] diff --git a/pallets/template/README.md b/pallets/template/README.md deleted file mode 100644 index 8d751a4..0000000 --- a/pallets/template/README.md +++ /dev/null @@ -1 +0,0 @@ -License: Unlicense \ No newline at end of file diff --git a/pallets/template/src/benchmarking.rs b/pallets/template/src/benchmarking.rs deleted file mode 100644 index d496a9f..0000000 --- a/pallets/template/src/benchmarking.rs +++ /dev/null @@ -1,20 +0,0 @@ -//! Benchmarking setup for pallet-template - -use super::*; - -#[allow(unused)] -use crate::Pallet as Template; -use frame_benchmarking::{benchmarks, whitelisted_caller}; -use frame_system::RawOrigin; - -benchmarks! { - do_something { - let s in 0 .. 100; - let caller: T::AccountId = whitelisted_caller(); - }: _(RawOrigin::Signed(caller), s) - verify { - assert_eq!(Something::::get(), Some(s)); - } - - impl_benchmark_test_suite!(Template, crate::mock::new_test_ext(), crate::mock::Test); -} diff --git a/pallets/template/src/lib.rs b/pallets/template/src/lib.rs deleted file mode 100644 index 4630e34..0000000 --- a/pallets/template/src/lib.rs +++ /dev/null @@ -1,104 +0,0 @@ -#![cfg_attr(not(feature = "std"), no_std)] - -/// Edit this file to define custom logic or remove it if it is not needed. -/// Learn more about FRAME and the core library of Substrate FRAME pallets: -/// -pub use pallet::*; - -#[cfg(test)] -mod mock; - -#[cfg(test)] -mod tests; - -#[cfg(feature = "runtime-benchmarks")] -mod benchmarking; - -#[frame_support::pallet] -pub mod pallet { - use frame_support::pallet_prelude::*; - use frame_system::pallet_prelude::*; - - #[pallet::pallet] - #[pallet::generate_store(pub(super) trait Store)] - pub struct Pallet(_); - - /// Configure the pallet by specifying the parameters and types on which it depends. - #[pallet::config] - pub trait Config: frame_system::Config { - /// Because this pallet emits events, it depends on the runtime's definition of an event. - type RuntimeEvent: From> + IsType<::RuntimeEvent>; - } - - // The pallet's runtime storage items. - // https://docs.substrate.io/main-docs/build/runtime-storage/ - #[pallet::storage] - #[pallet::getter(fn something)] - // Learn more about declaring storage items: - // https://docs.substrate.io/main-docs/build/runtime-storage/#declaring-storage-items - pub type Something = StorageValue<_, u32>; - - // Pallets use events to inform users when important changes are made. - // https://docs.substrate.io/main-docs/build/events-errors/ - #[pallet::event] - #[pallet::generate_deposit(pub(super) fn deposit_event)] - pub enum Event { - /// Event documentation should end with an array that provides descriptive names for event - /// parameters. [something, who] - SomethingStored { something: u32, who: T::AccountId }, - } - - // Errors inform users that something went wrong. - #[pallet::error] - pub enum Error { - /// Error names should be descriptive. - NoneValue, - /// Errors should have helpful documentation associated with them. - StorageOverflow, - } - - // Dispatchable functions allows users to interact with the pallet and invoke state changes. - // These functions materialize as "extrinsics", which are often compared to transactions. - // Dispatchable functions must be annotated with a weight and must return a DispatchResult. - #[pallet::call] - impl Pallet { - /// An example dispatchable that takes a singles value as a parameter, writes the value to - /// storage and emits an event. This function must be dispatched by a signed extrinsic. - #[pallet::call_index(0)] - #[pallet::weight(10_000 + T::DbWeight::get().writes(1).ref_time())] - pub fn do_something(origin: OriginFor, something: u32) -> DispatchResult { - // Check that the extrinsic was signed and get the signer. - // This function will return an error if the extrinsic is not signed. - // https://docs.substrate.io/main-docs/build/origins/ - let who = ensure_signed(origin)?; - - // Update storage. - >::put(something); - - // Emit an event. - Self::deposit_event(Event::SomethingStored { something, who }); - // Return a successful DispatchResultWithPostInfo - Ok(()) - } - - /// An example dispatchable that may throw a custom error. - #[pallet::call_index(1)] - #[pallet::weight(10_000 + T::DbWeight::get().reads_writes(1,1).ref_time())] - pub fn cause_error(origin: OriginFor) -> DispatchResult { - let _who = ensure_signed(origin)?; - - // Read a value from storage. - match >::get() { - // Return an error if the value has not been set. - None => return Err(Error::::NoneValue.into()), - Some(old) => { - // Increment the value read from storage; will error in the event of overflow. - let new = old.checked_add(1).ok_or(Error::::StorageOverflow)?; - // Update the value in storage with the incremented result. - >::put(new); - Ok(()) - }, - } - } - } -} diff --git a/pallets/template/src/mock.rs b/pallets/template/src/mock.rs deleted file mode 100644 index 989681f..0000000 --- a/pallets/template/src/mock.rs +++ /dev/null @@ -1,59 +0,0 @@ -use crate as pallet_template; -use frame_support::traits::{ConstU16, ConstU64}; -use frame_system as system; -use sp_core::H256; -use sp_runtime::{ - testing::Header, - traits::{BlakeTwo256, IdentityLookup}, -}; - -type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic; -type Block = frame_system::mocking::MockBlock; - -// Configure a mock runtime to test the pallet. -frame_support::construct_runtime!( - pub enum Test where - Block = Block, - NodeBlock = Block, - UncheckedExtrinsic = UncheckedExtrinsic, - { - System: frame_system, - TemplateModule: pallet_template, - } -); - -impl system::Config for Test { - type BaseCallFilter = frame_support::traits::Everything; - type BlockWeights = (); - type BlockLength = (); - type DbWeight = (); - type RuntimeOrigin = RuntimeOrigin; - type RuntimeCall = RuntimeCall; - type Index = u64; - type BlockNumber = u64; - type Hash = H256; - type Hashing = BlakeTwo256; - type AccountId = u64; - type Lookup = IdentityLookup; - type Header = Header; - type RuntimeEvent = RuntimeEvent; - type BlockHashCount = ConstU64<250>; - type Version = (); - type PalletInfo = PalletInfo; - type AccountData = (); - type OnNewAccount = (); - type OnKilledAccount = (); - type SystemWeightInfo = (); - type SS58Prefix = ConstU16<42>; - type OnSetCode = (); - type MaxConsumers = frame_support::traits::ConstU32<16>; -} - -impl pallet_template::Config for Test { - type RuntimeEvent = RuntimeEvent; -} - -// Build genesis storage according to the mock runtime. -pub fn new_test_ext() -> sp_io::TestExternalities { - system::GenesisConfig::default().build_storage::().unwrap().into() -} diff --git a/pallets/template/src/tests.rs b/pallets/template/src/tests.rs deleted file mode 100644 index 7c2b853..0000000 --- a/pallets/template/src/tests.rs +++ /dev/null @@ -1,27 +0,0 @@ -use crate::{mock::*, Error, Event}; -use frame_support::{assert_noop, assert_ok}; - -#[test] -fn it_works_for_default_value() { - new_test_ext().execute_with(|| { - // Go past genesis block so events get deposited - System::set_block_number(1); - // Dispatch a signed extrinsic. - assert_ok!(TemplateModule::do_something(RuntimeOrigin::signed(1), 42)); - // Read pallet storage and assert an expected result. - assert_eq!(TemplateModule::something(), Some(42)); - // Assert that the correct event was deposited - System::assert_last_event(Event::SomethingStored { something: 42, who: 1 }.into()); - }); -} - -#[test] -fn correct_error_for_none_value() { - new_test_ext().execute_with(|| { - // Ensure the expected error is thrown when no value is present. - assert_noop!( - TemplateModule::cause_error(RuntimeOrigin::signed(1)), - Error::::NoneValue - ); - }); -} diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 2482de0..cfadcff 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -48,13 +48,11 @@ frame-benchmarking = { version = "4.0.0-dev", default-features = false, git = "h frame-system-benchmarking = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", optional = true, branch = "polkadot-v0.9.37" } # Local Dependencies -pallet-template = { version = "4.0.0-dev", default-features = false, path = "../pallets/template" } -pallet-permissions = { default-features = false, path = '../pallets/permissions' } -pallet-spaces = { default-features = false, path = '../pallets/spaces' } -pallet-posts = { default-features = false, path = '../pallets/posts' } -pallet-roles = { default-features = false, path = '../pallets/roles' } -pallet-space-follows = { default-features = false, path = '../pallets/space-follows' } - +pallet-permissions = { default-features = false, git = "https://github.com/dappforce/subsocial-parachain.git", rev = "035c651a03ba94d78f1d5dbc87a5f4461cfbb664" } +pallet-spaces = { default-features = false, git = "https://github.com/dappforce/subsocial-parachain.git", rev = "035c651a03ba94d78f1d5dbc87a5f4461cfbb664" } +pallet-posts = { default-features = false, git = "https://github.com/dappforce/subsocial-parachain.git", rev = "035c651a03ba94d78f1d5dbc87a5f4461cfbb664" } +pallet-roles = { default-features = false, git = "https://github.com/dappforce/subsocial-parachain.git", rev = "035c651a03ba94d78f1d5dbc87a5f4461cfbb664" } +pallet-space-follows = { default-features = false, git = "https://github.com/dappforce/subsocial-parachain.git", rev = "035c651a03ba94d78f1d5dbc87a5f4461cfbb664" } [build-dependencies] substrate-wasm-builder = { version = "5.0.0-dev", git = "https://github.com/paritytech/substrate.git", optional = true, branch = "polkadot-v0.9.37" } @@ -77,7 +75,6 @@ std = [ "pallet-grandpa/std", "pallet-randomness-collective-flip/std", "pallet-sudo/std", - "pallet-template/std", "pallet-timestamp/std", "pallet-transaction-payment-rpc-runtime-api/std", "pallet-transaction-payment/std", @@ -106,7 +103,6 @@ runtime-benchmarks = [ "frame-system/runtime-benchmarks", "pallet-balances/runtime-benchmarks", "pallet-grandpa/runtime-benchmarks", - "pallet-template/runtime-benchmarks", "pallet-timestamp/runtime-benchmarks", "sp-runtime/runtime-benchmarks", ] @@ -120,7 +116,6 @@ try-runtime = [ "pallet-grandpa/try-runtime", "pallet-randomness-collective-flip/try-runtime", "pallet-sudo/try-runtime", - "pallet-template/try-runtime", "pallet-permissions/try-runtime", "pallet-spaces/try-runtime", "pallet-roles/try-runtime", diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 78be479..9de39d2 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -47,9 +47,6 @@ use pallet_transaction_payment::{ConstFeeMultiplier, CurrencyAdapter, Multiplier pub use sp_runtime::BuildStorage; pub use sp_runtime::{Perbill, Permill}; -/// Import the template pallet. -pub use pallet_template; - /// An index to a block. pub type BlockNumber = u32; @@ -275,11 +272,6 @@ impl pallet_sudo::Config for Runtime { type RuntimeCall = RuntimeCall; } -/// Configure the pallet-template in pallets/template. -impl pallet_template::Config for Runtime { - type RuntimeEvent = RuntimeEvent; -} - use pallet_permissions::default_permissions::DefaultSpacePermissions; impl pallet_permissions::Config for Runtime { @@ -346,8 +338,7 @@ construct_runtime!( Balances: pallet_balances, TransactionPayment: pallet_transaction_payment, Sudo: pallet_sudo, - // Include the custom logic from the pallet-template in the runtime. - TemplateModule: pallet_template, + Permissions: pallet_permissions, Spaces: pallet_spaces, Roles: pallet_roles, @@ -399,7 +390,6 @@ mod benches { [frame_system, SystemBench::] [pallet_balances, Balances] [pallet_timestamp, Timestamp] - [pallet_template, TemplateModule] ); } diff --git a/scripts/init.sh b/scripts/init.sh index f976f72..991d307 100755 --- a/scripts/init.sh +++ b/scripts/init.sh @@ -5,8 +5,9 @@ set -e echo "*** Initializing WASM build environment" if [ -z $CI_PROJECT_NAME ] ; then - rustup update nightly + rustup update nightly-2022-11-15 rustup update stable fi -rustup target add wasm32-unknown-unknown --toolchain nightly +rustup target add wasm32-unknown-unknown --toolchain nightly-2022-11-15 +rustup override set nightly-2022-11-15 From e6ff2ddb2217b995b78aba02b41bbf81b8281f44 Mon Sep 17 00:00:00 2001 From: Vlad Proshchavaiev <32250097+F3Joule@users.noreply.github.com> Date: Wed, 8 Mar 2023 11:52:35 +0200 Subject: [PATCH 04/13] Update .gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index d934a8a..c86e18d 100644 --- a/.gitignore +++ b/.gitignore @@ -5,6 +5,7 @@ **/*.rs.bk .DS_Store +**/.idea/ # The cache for docker container dependency .cargo From 5aeedbbbcf23f9312ac19692adec648f4a5489d2 Mon Sep 17 00:00:00 2001 From: Vlad Proshchavaiev <32250097+F3Joule@users.noreply.github.com> Date: Wed, 8 Mar 2023 11:57:47 +0200 Subject: [PATCH 05/13] Remove template names --- node/Cargo.toml | 5 ++--- node/src/main.rs | 2 +- runtime/Cargo.toml | 5 ++--- 3 files changed, 5 insertions(+), 7 deletions(-) diff --git a/node/Cargo.toml b/node/Cargo.toml index 869da1a..a57ab9d 100644 --- a/node/Cargo.toml +++ b/node/Cargo.toml @@ -5,9 +5,8 @@ description = "A fresh FRAME-based Substrate node, ready for hacking." authors = ["Substrate DevHub "] homepage = "https://substrate.io/" edition = "2021" -license = "Unlicense" publish = false -repository = "https://github.com/substrate-developer-hub/substrate-node-template/" +repository = "https://github.com/dappforce/xsocial-testnet/" build = "build.rs" [package.metadata.docs.rs] @@ -43,7 +42,7 @@ sp-keyring = { version = "7.0.0", git = "https://github.com/paritytech/substrate frame-system = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -# These dependencies are used for the node template's RPCs +# These dependencies are used for the node's RPCs jsonrpsee = { version = "0.16.2", features = ["server"] } sc-rpc = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sp-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } diff --git a/node/src/main.rs b/node/src/main.rs index 426cbab..2d5052b 100644 --- a/node/src/main.rs +++ b/node/src/main.rs @@ -1,4 +1,4 @@ -//! Substrate Node Template CLI library. +//! Substrate Node CLI library. #![warn(missing_docs)] mod chain_spec; diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index cfadcff..83ae6b2 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -5,9 +5,8 @@ description = "A fresh FRAME-based Substrate node, ready for hacking." authors = ["Substrate DevHub "] homepage = "https://substrate.io/" edition = "2021" -license = "Unlicense" publish = false -repository = "https://github.com/substrate-developer-hub/substrate-node-template/" +repository = "https://github.com/dappforce/xsocial-testnet/" [package.metadata.docs.rs] targets = ["x86_64-unknown-linux-gnu"] @@ -39,7 +38,7 @@ sp-std = { version = "5.0.0", default-features = false, git = "https://github.co sp-transaction-pool = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sp-version = { version = "5.0.0", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -# Used for the node template's RPCs +# Used for the node's RPCs frame-system-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } pallet-transaction-payment-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } From b9178d36258bb85d78063cb84c566056efee406d Mon Sep 17 00:00:00 2001 From: Vlad Proshchavaiev <32250097+F3Joule@users.noreply.github.com> Date: Wed, 8 Mar 2023 11:58:00 +0200 Subject: [PATCH 06/13] Change spec and impl names --- runtime/src/lib.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 9de39d2..9354c43 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -94,8 +94,8 @@ pub mod opaque { // https://docs.substrate.io/main-docs/build/upgrade#runtime-versioning #[sp_version::runtime_version] pub const VERSION: RuntimeVersion = RuntimeVersion { - spec_name: create_runtime_str!("node-template"), - impl_name: create_runtime_str!("node-template"), + spec_name: create_runtime_str!("xsocial"), + impl_name: create_runtime_str!("subsocial-xsocial-testnet"), authoring_version: 1, // The version of the runtime specification. A full node will not attempt to use its native // runtime in substitute for the on-chain Wasm runtime unless all of `spec_name`, From 1b98cc17e25701dc8e42cff9240887b404d51990 Mon Sep 17 00:00:00 2001 From: Vlad Proshchavaiev <32250097+F3Joule@users.noreply.github.com> Date: Wed, 8 Mar 2023 15:46:21 +0200 Subject: [PATCH 07/13] Add custom chain specs --- Cargo.lock | 8 + docker-compose.yml | 17 - node/Cargo.toml | 2 + node/res/xsocial.json | 1055 ++++++++++++++++++++++++++++++++++++++++ node/src/chain_spec.rs | 70 ++- node/src/command.rs | 10 +- 6 files changed, 1139 insertions(+), 23 deletions(-) delete mode 100644 docker-compose.yml create mode 100644 node/res/xsocial.json diff --git a/Cargo.lock b/Cargo.lock index c48141d..cf229c7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2416,6 +2416,12 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" +[[package]] +name = "hex-literal" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0" + [[package]] name = "hkdf" version = "0.12.3" @@ -9363,10 +9369,12 @@ dependencies = [ "frame-benchmarking-cli", "frame-system", "futures", + "hex-literal", "jsonrpsee", "pallet-transaction-payment", "pallet-transaction-payment-rpc", "sc-basic-authorship", + "sc-chain-spec", "sc-cli", "sc-client-api", "sc-consensus", diff --git a/docker-compose.yml b/docker-compose.yml deleted file mode 100644 index bc1922f..0000000 --- a/docker-compose.yml +++ /dev/null @@ -1,17 +0,0 @@ -version: "3.2" - -services: - dev: - container_name: node-template - image: paritytech/ci-linux:production - working_dir: /var/www/node-template - ports: - - "9944:9944" - environment: - - CARGO_HOME=/var/www/node-template/.cargo - volumes: - - .:/var/www/node-template - - type: bind - source: ./.local - target: /root/.local - command: bash -c "cargo build --release && ./target/release/node-template --dev --ws-external" diff --git a/node/Cargo.toml b/node/Cargo.toml index a57ab9d..a4e45e9 100644 --- a/node/Cargo.toml +++ b/node/Cargo.toml @@ -18,7 +18,9 @@ name = "xsocial-node" [dependencies] clap = { version = "4.0.9", features = ["derive"] } futures = { version = "0.3.21", features = ["thread-pool"]} +hex-literal = "0.3.4" +sc-chain-spec = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sc-cli = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sp-core = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sc-executor = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } diff --git a/node/res/xsocial.json b/node/res/xsocial.json new file mode 100644 index 0000000..70015cc --- /dev/null +++ b/node/res/xsocial.json @@ -0,0 +1,1055 @@ +{ + "name": "XSocial Testnet", + "id": "xsocial_testnet", + "chainType": "Live", + "bootNodes": [], + "telemetryEndpoints": [ + [ + "/dns/telemetry.polkadot.io/tcp/443/x-parity-wss/%2Fsubmit%2F", + 0 + ] + ], + "protocolId": "subx", + "properties": { + "ss58Format": 28, + "tokenDecimals": 10, + "tokenSymbol": "SUB" + }, + "codeSubstitutes": {}, + "genesis": { + "raw": { + "top": { + "0x22b42e0b5063ee90848a8a42dca755294e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710": "0x01", + "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545", + "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545", + "0x26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439": "0x01", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9cb57c70ef83699051944b7b796a4ca3da8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45": "0x0000000000000000010000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0x91011c78736f6369616c", + "0x3a636f6465": "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", + "0x3a65787472696e7369635f696e646578": "0x00000000", + "0x3a6772616e6470615f617574686f726974696573": "0x0108419c48625508cc74c8c125dd0132158d3583b479975e516c3c2cc1457d11a7c50100000000000000b553650f5032ecadba5df3bd35e8d280bc6f5cdff1beda8c504d6cfecc89c63a0100000000000000", + "0x3f1467a096bcd71a5b6a0c8155e20810308ce9615de0775a82f8a94dc3d285a1": "0x01", + "0x3f1467a096bcd71a5b6a0c8155e208103f2edf3bdf381debe331ab7446addfdc": "0x000064a7b3b6e00d0000000000000000", + "0x3f1467a096bcd71a5b6a0c8155e208104e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x57f8dc2f5ab09467896f47300f0424384e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x57f8dc2f5ab09467896f47300f0424385e0621c4869aa60c02be9adcc98a0d1d": "0x08d4f4482d82913b5a4ef195bba7ec5567ee04b6ea784139c04ee5e77530670149640f97526d653b620d1ccbdefa4cb212cc0dfc76f77a0f631f96f009d986464b", + "0x5c0d1176a568c1f92944340dbfed9e9c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0x5c0d1176a568c1f92944340dbfed9e9c530ebca703c85910e7164cb7d1c9e47b": "0xa8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45", + "0x5f9cc45b7a00c5899361e1c6099678dc4e7b9012096b41c4eb3aaf947f6ea429": "0x0400", + "0x5f9cc45b7a00c5899361e1c6099678dc8a2d09463effcc78a22d75b9cb87dffc": "0x0000000000000000", + "0x5f9cc45b7a00c5899361e1c6099678dcd47cb8f5328af743ddfb361e7180e7fcbb1bdbcacd6ac9340000000000000000": "0x00000000", + "0xa31f5a5260e78d7df27950c13d40704c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xbd2a529379475088d3e29a918cd478724e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xc2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", + "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x00000000000000100000000000000000", + "0xc2b6ac49ee131be4de5527a2ccab4a674e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xcc98f986f653d94b4d47ed05aa4522194e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332100f527e678449dd0f100000000000000": "0xf100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321014cbc17139b3d926702000000000000": "0x6702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321016e8f5b868e2bca6c01000000000000": "0x6c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332101fa6b2a2461b71ff801000000000000": "0xf801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321023723973fb9bea37301000000000000": "0x7301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210268f57373d4ff3c0902000000000000": "0x0902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210349a011341eed9a0600000000000000": "0x0600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321039fdf88337e2f034600000000000000": "0x4600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332103bb01328092cd10dd01000000000000": "0xdd01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210402741d9c3b1c6b1a03000000000000": "0x1a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210470dd70e52b302f2003000000000000": "0x2003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332104ad0e1944ef9568dc03000000000000": "0xdc03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332105734c99d41b6da7de02000000000000": "0xde02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210597ef7a778d51141701000000000000": "0x1701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210599f1b0e0c174562001000000000000": "0x2001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332105aec83a3ed8843dfd02000000000000": "0xfd02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332105be9b3941f8ea277f03000000000000": "0x7f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332106142cd69486b73b3f00000000000000": "0x3f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210627acba370b41a1ab03000000000000": "0xab03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321062daa518e0fcb56ad00000000000000": "0xad00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210645be279ea025975703000000000000": "0x5703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210666f3a9b6889f083803000000000000": "0x3803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210698271bc9c5d94fa000000000000000": "0xa000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332107aed72891886db09003000000000000": "0x9003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332107b75db3e3985cb70d02000000000000": "0x0d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332107c49cc041e06aac8300000000000000": "0x8300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332107dd1e9a9b10c6bc0803000000000000": "0x0803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332107e3a8cb90f303c3c701000000000000": "0xc701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321085c71218f72091d5d02000000000000": "0x5d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332108c0254bb52d4e807b02000000000000": "0x7b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332108cdd69027a0a6747a01000000000000": "0x7a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210901e4ef315cf20e7001000000000000": "0x7001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210925d6a980f243b95f03000000000000": "0x5f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321093e2ade1f3bc5db8602000000000000": "0x8602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210961260c772739bdcb03000000000000": "0xcb03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210963eafefec0ab6a3c03000000000000": "0x3c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210971d2f0821f235cfc00000000000000": "0xfc00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321098eb895db2c69129800000000000000": "0x9800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210990f147ade5e8e9c902000000000000": "0xc902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332109b30a202c3ddd2e9d02000000000000": "0x9d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332109d40792b3d38191ba03000000000000": "0xba03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332109d74605c153e24f6f03000000000000": "0x6f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a0029fea3d318c2ac00000000000000": "0xac00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a1e16744fdd9a1c0002000000000000": "0x0002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a28905153c8d9622303000000000000": "0x2303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a50cbf184f648993e03000000000000": "0x3e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a59ed87828062710303000000000000": "0x0303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a72b2109d3b9ad8c700000000000000": "0xc700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210b091b5a339fe9ff8e03000000000000": "0x8e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210b77c4f216fe975abb03000000000000": "0xbb03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210b9b7c2374d1ed275b01000000000000": "0x5b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210baa3fa201cb7f548403000000000000": "0x8403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210c1d3ad0589a29a78000000000000000": "0x8000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210c4330def9ebd14a3703000000000000": "0x3703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210c6db1ad6dc7331a4402000000000000": "0x4402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210ce9fbe9f08c4294e601000000000000": "0xe601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210cfaeacc491573ad6001000000000000": "0x6001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210d4d4083a87d257ce801000000000000": "0xe801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210d88aacecf92646d1b01000000000000": "0x1b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210e2234a0e58c0150a101000000000000": "0xa101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210eafef985ba61d976202000000000000": "0x6202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210efb6b72d553e415df02000000000000": "0xdf02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210efb6bd85c58cd106a02000000000000": "0x6a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210f00488539b7a6a7d602000000000000": "0xd602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210f2563426d99be212a01000000000000": "0x2a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210f5de6380c21e6fb6802000000000000": "0x6802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210f5e0a10cbce516d7303000000000000": "0x7303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210fb45163014518033003000000000000": "0x3003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332110b1ef8e726bc48b6002000000000000": "0x6002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321110cfcd5eb55e9e62103000000000000": "0x2103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332111434190a0e85a126703000000000000": "0x6703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321114e7435772b4f75ea01000000000000": "0xea01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321116e5e0702e35fb96e00000000000000": "0x6e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211191a1ff026ffceb6d02000000000000": "0x6d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332111bb383051a7fcb09600000000000000": "0x9600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332111cb28a718a6dfb98901000000000000": "0x8901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332111e1d47c7bedfa485a03000000000000": "0x5a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332111f32d9aa0abc6e05f02000000000000": "0x5f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211206bc4d032894a81c00000000000000": "0x1c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321122ed5bd1dd475121503000000000000": "0x1503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321124cf5ab9c606b441d02000000000000": "0x1d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211291d7f46d122bf3bc01000000000000": "0xbc01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332112b8a498d564d2456c03000000000000": "0x6c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332112bb5650a0e73cb4fb00000000000000": "0xfb00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332112c0f2f553de1f16b501000000000000": "0xb501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321136c4064f0f68f654900000000000000": "0x4900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332113994971f5e753a49a00000000000000": "0x9a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321139a57f04a423a3ecb02000000000000": "0xcb02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332113a8d4384914250ed302000000000000": "0xd302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211455fc9a4811ffaed502000000000000": "0xd502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332114fb739b8333fd539601000000000000": "0x9601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332115391d26cd0f8e971303000000000000": "0x1303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321157b13af9d750777d000000000000000": "0xd000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332115bfc7c35fce3aa69200000000000000": "0x9200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332115c4ea6eef6663fb7202000000000000": "0x7202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332115f5478a4898eefa9501000000000000": "0x9501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332116efcce1ce9f16d6bd02000000000000": "0xbd02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321173591d7eb1b06693e02000000000000": "0x3e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321179041b8a624120fd102000000000000": "0xd102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211795ca862faec0dc3e00000000000000": "0x3e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332117c4ce9ec6fcb0a64b00000000000000": "0x4b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332118d4fdcb6d97cda51100000000000000": "0x1100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332118d66624a82f8ce64a02000000000000": "0x4a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332118fd021b99698289ac03000000000000": "0xac03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321192cb54b38e305c9d401000000000000": "0xd401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332119371f0b8eb58cfc0901000000000000": "0x0901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321195443923204c265e502000000000000": "0xe502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321198e9190d2a46f734803000000000000": "0x4803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211a1b3e04e244cde33501000000000000": "0x3501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211a4ca3d2f48bb41b2603000000000000": "0x2603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211a7595a63ca78fe6d501000000000000": "0xd501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211a8f8f0aefd526adb700000000000000": "0xb700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211ab1297d84b5a28f0103000000000000": "0x0103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211bac7511b33e8417ba01000000000000": "0xba01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211bc328bf9be0ce6ef700000000000000": "0xf700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211c478eeb0d5416db7e03000000000000": "0x7e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211dae9e3480e087673c01000000000000": "0x3c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211dc20f920c5874633802000000000000": "0x3802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211ddc5c258ceb41cb6701000000000000": "0x6701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211df5194bbb9a7719c300000000000000": "0xc300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211df7fde8e0ffb6104903000000000000": "0x4903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211e096e9f7cf70a9dd100000000000000": "0xd100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211e30680c6c0058793a02000000000000": "0x3a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211e5814b1935f0590a202000000000000": "0xa202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211e6afb12afa810e50403000000000000": "0x0403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211ede9b9f5ad25163bf00000000000000": "0xbf00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211f2514a57b3c2045b102000000000000": "0xb102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211f353ce9fd6e55172100000000000000": "0x2100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211fa7eaa95441943a2400000000000000": "0x2400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211fd02315cea3c63ad403000000000000": "0xd403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211ff0db6ff76a2e96c203000000000000": "0xc203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332120d23dec54669123ae03000000000000": "0xae03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321210d292d3d5908e90101000000000000": "0x0101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321215114c642fa12de7300000000000000": "0x7300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212159bae8d0723c3b8103000000000000": "0x8103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332121a7ae0520deb00b6a00000000000000": "0x6a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332121bcf2f351133e974d00000000000000": "0x4d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332121e2daadea7f5dd03101000000000000": "0x3101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321221afeed29bdac66ac02000000000000": "0xac02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321224ffc5308e5c40e5300000000000000": "0x5300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332122581317f09f86134e01000000000000": "0x4e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332122cfc34745705b180a00000000000000": "0x0a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332122deaf27467121b0b100000000000000": "0xb100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321234c02bf6c5459854c00000000000000": "0x4c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332123ae5c0d39d9e338f202000000000000": "0xf202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212439d5a77e274dae3a03000000000000": "0x3a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212451a40f66b53ff01e01000000000000": "0x1e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212465d69326de41f83d03000000000000": "0x3d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332124bc857f8ad35c629402000000000000": "0x9402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321251b1f5223922e204902000000000000": "0x4902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321258badbf34cb04769203000000000000": "0x9203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332125d1fb30c2029a523d02000000000000": "0x3d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332125d712aba4c4a50efa01000000000000": "0xfa01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212600c8393d63e82ce401000000000000": "0xe401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321261ecf14163a0dd45602000000000000": "0x5602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212648c23e4f84aeaf2c01000000000000": "0x2c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212667c50999720e85d203000000000000": "0xd203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321266b83bfb98ff6925b03000000000000": "0x5b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332126760b9a3d753b387601000000000000": "0x7601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321271f06de3f2150298a01000000000000": "0x8a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321277c52a11fadf5753900000000000000": "0x3900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321277dd0eb513b406f5102000000000000": "0x5102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321280766a42c408a514b02000000000000": "0x4b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212817d58bb7552e4be002000000000000": "0xe002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212858f306143eb116bd01000000000000": "0xbd01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321290b02fdb1d3b6c78c01000000000000": "0x8c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321291577b449b5ee83e102000000000000": "0xe102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332129ab61e2736e19099902000000000000": "0x9902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332129f024a69d0b190bfe01000000000000": "0xfe01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212a44911af53be0713f03000000000000": "0x3f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212a50ebf8862552621600000000000000": "0x1600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212adc162cfa496fceb202000000000000": "0xb202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b487ef7f1532a6ecc03000000000000": "0xcc03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b4a43bf42bd300c9302000000000000": "0x9302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b5abcdef0e7cd87e003000000000000": "0xe003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b6dfa2999cd6d3fc801000000000000": "0xc801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b705d7c8f1976650c03000000000000": "0x0c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b8d936ed1c74e3b0a03000000000000": "0x0a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212c0bd437670ed7af6603000000000000": "0x6603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212c285637a2a45b198900000000000000": "0x8900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212ca3af29fc20a6fe6201000000000000": "0x6201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212cec332c92bfe0296d00000000000000": "0x6d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212d3947acf6aa8347d300000000000000": "0xd300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212d4cde4944654bd01e03000000000000": "0x1e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212dbdf2750b2eb3189f03000000000000": "0x9f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212e08d563f4d232bba701000000000000": "0xa701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212e31413c2341cc87f802000000000000": "0xf802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212e320f73ec383afe8f03000000000000": "0x8f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212e5bf915e7f3b8768f02000000000000": "0x8f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212f56e5005e118546b703000000000000": "0xb703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212fda93ebbd8b89f2a100000000000000": "0xa100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321300635051113bb426502000000000000": "0x6502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321300cb436f4d09ff36b00000000000000": "0x6b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321302fe276d44fffb24301000000000000": "0x4301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321305e8ca811d65a0adf01000000000000": "0xdf01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332130b9de03fa5963d90001000000000000": "0x0001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332130cd467b4f58c59e5a00000000000000": "0x5a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321318d761d0eca4c7c5803000000000000": "0x5803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332131a631a46a9ff78ca702000000000000": "0xa702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332131da77d497250b797b01000000000000": "0x7b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332131fb44d9d74eb7b79f01000000000000": "0x9f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321320a04fab7be95873300000000000000": "0x3300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321320f62ffe8f27a3eef00000000000000": "0xef00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132497a2b8fc9d85fa503000000000000": "0xa503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132b010cc535cefe9d003000000000000": "0xd003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132c977c95d2ca3652b01000000000000": "0x2b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132df4a9b227fe64f8503000000000000": "0x8503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132ecbaedcaea8fe01b02000000000000": "0x1b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132fc9237102ed443b301000000000000": "0xb301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332133313fa8e5bf443f1102000000000000": "0x1102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332133805ba2ef00a872e503000000000000": "0xe503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321338f735fcddf5eb86f01000000000000": "0x6f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321339305e0836977655a02000000000000": "0x5a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332133c05c8699d0b83c3a00000000000000": "0x3a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332133d512ebf46134033503000000000000": "0x3503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213469c54e8cb035fd2501000000000000": "0x2501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213476069ad9d6cf232402000000000000": "0x2402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332134a31bcc4026bb35d200000000000000": "0xd200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332134b9cf520b3a72facd00000000000000": "0xcd00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332135ffab14b86311adfc01000000000000": "0xfc01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321365e51413fe96b300701000000000000": "0x0701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332136edb8a5e921abd52201000000000000": "0x2201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321370a179fcbeaed6ff601000000000000": "0xf601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213780a7002d1441847402000000000000": "0x7402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321382beaa3e0126a64b101000000000000": "0xb101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321385a7c9189ec3ef56503000000000000": "0x6503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332138735139f5ec7bdbed00000000000000": "0xed00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332138d630687d0b8043df00000000000000": "0xdf00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332138f983c96fa07e8b6c00000000000000": "0x6c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321393c986bf9f3d0468301000000000000": "0x8301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213955b1c81ec29ffa2800000000000000": "0x2800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213958af96072638e07901000000000000": "0x7901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213995dad07cbfa5a80c00000000000000": "0x0c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332139c7151c9953b8c7c702000000000000": "0xc702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213a76cd24b2006f31b401000000000000": "0xb401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213a8dd62119c6aa109d03000000000000": "0x9d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213b41a50021d39eb9cf00000000000000": "0xcf00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213b497aadda7841567502000000000000": "0x7502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213b7edcbd7eaf2e7de802000000000000": "0xe802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213c201a3ec20429352503000000000000": "0x2503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213c26619616d20379f702000000000000": "0xf702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213c543ab4f6eb65d02c02000000000000": "0x2c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213ca24ea29258da146601000000000000": "0x6601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213cd4d9891d52f2595403000000000000": "0x5403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213cdb013f6c570e44c802000000000000": "0xc802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213ceae3e27dc4313d1900000000000000": "0x1900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d2065b4917515953700000000000000": "0x3700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d24d187ecfe56c7c001000000000000": "0xc001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d2b6c6e36aa26c25f01000000000000": "0x5f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d345cc367f497b1a300000000000000": "0xa300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d3c91bde13c2a550b02000000000000": "0x0b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d59c2d52d0bbe890500000000000000": "0x0500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d5d7a338175da4b2802000000000000": "0x2802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213e4b28e5094809635f00000000000000": "0x5f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213ef1ca0a392a5c275802000000000000": "0x5802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213f6023e6df6aa02aff00000000000000": "0xff00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213fd036fcab4bbf624702000000000000": "0x4702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321407ad79c61e41d6fe602000000000000": "0xe602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321408f6b430ab072206f02000000000000": "0x6f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332140a9acf4c9602a793102000000000000": "0x3102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321410e1122416567d2d902000000000000": "0xd902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332141154d73bae6fb995c02000000000000": "0x5c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332141426c31b15c8fe21c02000000000000": "0x1c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214148eca76d16b8870300000000000000": "0x0300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214275c7ba75a8dd931700000000000000": "0x1700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321427618a74bcded14ca01000000000000": "0xca01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332142ebe09f792ca84c0e00000000000000": "0x0e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332142fde0e95415eb62ff01000000000000": "0xff01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321437475f33024ff040d00000000000000": "0x0d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321438ae91e4b411aceb903000000000000": "0xb903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332143a0673a1700f1685103000000000000": "0x5103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332143e084f4cb631cf3a402000000000000": "0xa402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321440e4ae272346968f201000000000000": "0xf201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321449501768c52f705d303000000000000": "0xd303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332144d13d131a792399c201000000000000": "0xc201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332144df452ba38e01e39c02000000000000": "0x9c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332144fa244f82e95fa3c401000000000000": "0xc401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214549f27afbed5042be03000000000000": "0xbe03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321456f7e3c7ea412be5402000000000000": "0x5402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332145efe567a97880592d00000000000000": "0x2d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332146103834e980e5c92600000000000000": "0x2600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321463729b795ab910f9b03000000000000": "0x9b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214641cff150196278ce00000000000000": "0xce00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214658612a8b06aa047e00000000000000": "0x7e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321469bcbea67835b714b01000000000000": "0x4b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332146c50c7aa08e4c06e101000000000000": "0xe101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332146d4f2a789e1ffcba902000000000000": "0xa902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321478545fcc72f01318803000000000000": "0x8803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332147c35e051acca3529d01000000000000": "0x9d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321480a83a5d6f761917803000000000000": "0x7803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214810122ff0a3cbbfd001000000000000": "0xd001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332148682ae90e82eb67b902000000000000": "0xb902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321487e27ef2eb8e7ca4303000000000000": "0x4303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321496333e57d2bbfd4da00000000000000": "0xda00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321499a6c87222d3fe5e803000000000000": "0xe803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321499ac0b5b8bbae27a800000000000000": "0xa800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332149cf49b35eecb82c8702000000000000": "0x8702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214a3a545792a96255d803000000000000": "0xd803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214a621d4ae264efd9dd02000000000000": "0xdd02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214aa9a36683861ae67e02000000000000": "0x7e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214abfa797deaafc0c6301000000000000": "0x6301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214b2fe67da3498910e603000000000000": "0xe603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214c195cb97731ce7d6500000000000000": "0x6500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214c3c66260a77e3531101000000000000": "0x1101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214c5857f7051a0a39e800000000000000": "0xe800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214c65ef5594bda4846902000000000000": "0x6902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214c75308a323b74702a02000000000000": "0x2a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214cbcff36cff93d9c8002000000000000": "0x8002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214ceac484714766e7b803000000000000": "0xb803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214d1a715bead5d5044403000000000000": "0x4403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214d3a04ec3457e861dd00000000000000": "0xdd00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214d64a3445280429cff02000000000000": "0xff02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214dd38f46c9bfed8e0603000000000000": "0x0603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214e24ac59698cb4f20800000000000000": "0x0800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214e6b062fcebd37bc9a02000000000000": "0x9a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214f1b4c97d21d3902fa02000000000000": "0xfa02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214f5cce6d93da4129c102000000000000": "0xc102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214f6b83b6d9d3e7d38102000000000000": "0x8102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214f72ec67dce29af47102000000000000": "0x7102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214f73f9cf6b19dcc85002000000000000": "0x5002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214fca4cb035ea49795302000000000000": "0x5302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214fd06dfcc1fd58d25a01000000000000": "0x5a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332150eb9b636bda43607a03000000000000": "0x7a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332150f7a4523e93dbe0d600000000000000": "0xd600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215103bd9ba69515198a02000000000000": "0x8a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321511ead6239a439d96403000000000000": "0x6403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332151350afbf9f16e2f3602000000000000": "0x3602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332151c38fc0a8bc4897b203000000000000": "0xb203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321523875990d56f2d40502000000000000": "0x0502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321526ee91b8b3cd8251d01000000000000": "0x1d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215278a13a545710341f03000000000000": "0x1f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332152fb5595e0a3314cd702000000000000": "0xd702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215343d1b66f8056b52a00000000000000": "0x2a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332153eb37cb9f8606451f02000000000000": "0x1f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321540c35dba9765feccf01000000000000": "0xcf01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321548736d6bc9abf49cd01000000000000": "0xcd01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332154bcbda5c12e06014a00000000000000": "0x4a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332154c22ea28bd0c0dd4101000000000000": "0x4101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321551aabf1b3e3a8da3702000000000000": "0x3702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215555fa73093fa5a93403000000000000": "0x3403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332155709dd9b875a63a5d03000000000000": "0x5d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321557a13668d86eedbfa00000000000000": "0xfa00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332155e4fd6a40cd76080700000000000000": "0x0700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332156531103b3a002d73603000000000000": "0x3603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321571deabf2557dfc5ad02000000000000": "0xad02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321575519e2c5e4d0a9b001000000000000": "0xb001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215774f4008503726ea903000000000000": "0xa903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332157c445ec623c69f66d01000000000000": "0x6d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215801df91cf1530403100000000000000": "0x3100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321580a8bcaa2063eeae700000000000000": "0xe700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321582546570b1e5c6f1103000000000000": "0x1103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321583264242e08b658be02000000000000": "0xbe02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332158673825653c962c3e01000000000000": "0x3e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321587da4540af6276bc502000000000000": "0xc502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332158c1a279f846588b1703000000000000": "0x1703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332158c4a70573b6a0e61f00000000000000": "0x1f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215928dcc6901f246db702000000000000": "0xb702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321592a90ee9536ce99e400000000000000": "0xe400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321597d500c272aeeebc800000000000000": "0xc800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215a25fdf7cb7c62f7eb01000000000000": "0xeb01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215a4a66d80f6e679ea102000000000000": "0xa102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215a9aa2d47d65e191bb02000000000000": "0xbb02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215adf1a16cf4775c24701000000000000": "0x4701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215b04c92d4f30c5052e02000000000000": "0x2e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215b35a2d533ef39a08b03000000000000": "0x8b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215b4caf61c442a1a4f400000000000000": "0xf400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215bb7114a59e1574e4602000000000000": "0x4602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215bb7ad8b4fd0fd634302000000000000": "0x4302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215bc7c5fd0f633d441201000000000000": "0x1201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215c7abdb05ddb7ae86101000000000000": "0x6101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215c98370106ffd69cad01000000000000": "0xad01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215d23c4babf810f7ce402000000000000": "0xe402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215d772bdda79b2c566b01000000000000": "0x6b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215d7f268015bd5a67a302000000000000": "0xa302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215da817addd722b9f9a03000000000000": "0x9a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215de4a730373baee1c303000000000000": "0xc303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215e80f4afc634f05eef02000000000000": "0xef02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215ea8a9a01b3fb552ab00000000000000": "0xab00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215eed97c08ff9f8e5a002000000000000": "0xa002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215efe29c2558ffe722a03000000000000": "0x2a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215f3bb3cb13aff9cf6b02000000000000": "0x6b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215f43ad3f8d3383f9c002000000000000": "0xc002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215f6dc50e853f177f5503000000000000": "0x5503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321605cb1a64e2456dc9103000000000000": "0x9103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321608b2ed0ece55eacb701000000000000": "0xb701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332161291dfa3f5cea782701000000000000": "0x2701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321612d7c24647a931e0f03000000000000": "0x0f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321613700e5ee6d8b327f00000000000000": "0x7f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216152dc7e51742f9bba00000000000000": "0xba00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332161690a8517e5e2be2d02000000000000": "0x2d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216179a086b72127e56b03000000000000": "0x6b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332161f8d0a83b6e48e97302000000000000": "0x7302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216226b79dd45e4bc24e03000000000000": "0x4e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321624188c0d92477599001000000000000": "0x9001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216264fa86046f1e414d02000000000000": "0x4d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332162699aa57da216e0e301000000000000": "0xe301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332162abe5c68b5dce3de203000000000000": "0xe203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332162e44a2270679c1e9502000000000000": "0x9502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332163154cba480f25c38600000000000000": "0x8600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321632f25d10c90de9ac602000000000000": "0xc602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321636ccae8e7ceac1c7c03000000000000": "0x7c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321638742a1b96bbd5ef901000000000000": "0xf901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332163a9b3a3eac94f4e3402000000000000": "0x3402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332163e579b7c8311ee09301000000000000": "0x9301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321641e7004d0ce32027d02000000000000": "0x7d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321644882942b79816b4000000000000000": "0x4000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321644fa0c536240b9d4d01000000000000": "0x4d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332164671a5d3c56dd6c4501000000000000": "0x4501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216511b75bc59b5da9e100000000000000": "0xe100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332165c3739859ae3ee01002000000000000": "0x1002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332165f4b9479eb671fc4a03000000000000": "0x4a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216644fdb82aa2f7936e02000000000000": "0x6e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332166776c0a6ddef5b23502000000000000": "0x3502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332166f8b173e282bed9fb02000000000000": "0xfb02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332167ae7f0a8e5040510b01000000000000": "0x0b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332167c5e26395ac30a7ab02000000000000": "0xab02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216808afb4771f54a48302000000000000": "0x8302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321680f0cb6825297207903000000000000": "0x7903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321682e924452d5514a2203000000000000": "0x2203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332168f492c97d2b39f7aa01000000000000": "0xaa01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216a29b535b30fafc9ac01000000000000": "0xac01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216ae2dc69d7df92c9fe00000000000000": "0xfe00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216b02308cb80992b8ec02000000000000": "0xec02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216bcf6e6b1c8dfc250501000000000000": "0x0501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216c5836ddb821f4b4ea00000000000000": "0xea00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216c78df2c4542c7cca403000000000000": "0xa403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216c7faede5e7d3e672f02000000000000": "0x2f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216cf74fa0be5d030fe001000000000000": "0xe001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216d30aa37d49d892a9b00000000000000": "0x9b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216d3847e23b24dd7c2b02000000000000": "0x2b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216d6c3fe0517fcae64703000000000000": "0x4703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216d72680a04245cc09102000000000000": "0x9102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216d79bd915a49ee691a01000000000000": "0x1a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216dc9bd32090cf7934e00000000000000": "0x4e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216e28b94bbd691ec77101000000000000": "0x7101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216ef1ad264fd6f28dc402000000000000": "0xc402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216f204c0bf41378dbb300000000000000": "0xb300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216f372e6984eb562f9f02000000000000": "0x9f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216fd21a0b40ae5fa77100000000000000": "0x7100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216fda5424bf7f270d1802000000000000": "0x1802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216ff52536e43c14fa8e00000000000000": "0x8e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217059cbc5776722ffb901000000000000": "0xb901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321705ea5514a551f06a703000000000000": "0xa703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217079b0b54b2b6967cb00000000000000": "0xcb00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332170ac3beea03077524802000000000000": "0x4802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217148994bd857d9ac5203000000000000": "0x5203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217189aee734dd3c015303000000000000": "0x5303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332171b9dff0311471c5e302000000000000": "0xe302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217209eb482c58fcf1da03000000000000": "0xda03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321720f3db03c1656c44901000000000000": "0x4901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321721f9466891c501c2703000000000000": "0x2703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332172261bfb90131180b801000000000000": "0xb801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217280a2f3a49ed06bd802000000000000": "0xd802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321728b299207fe86029602000000000000": "0x9602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217294404b094ed48da303000000000000": "0xa303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217347bf132afeb9644b03000000000000": "0x4b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321737fd76268c213722300000000000000": "0x2300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332173cfed14b3ee0c588203000000000000": "0x8203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321741c779bb16404ac8200000000000000": "0x8200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332175389c626bd39c2a6800000000000000": "0x6800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332175fd31fedc867909a803000000000000": "0xa803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321768cae3cf77c62089701000000000000": "0x9701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332176b0689ceeacc6790801000000000000": "0x0801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217711efa8f93cc4375e00000000000000": "0x5e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332177136c612e5edef95201000000000000": "0x5201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321773c7f98b1b7fb0e5501000000000000": "0x5501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332177b86242480f8d10da02000000000000": "0xda02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332177eaf275b3f0d46fb500000000000000": "0xb500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321780485b0033b96431401000000000000": "0x1401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321785e1defccaa4522e900000000000000": "0xe900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321786810de53969faea501000000000000": "0xa501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332178700b8b6cb34869b603000000000000": "0xb603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217958e07e3af956c10201000000000000": "0x0201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321797b8c7bc8d473c5eb02000000000000": "0xeb02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332179bdacc5a4b0dfa2c500000000000000": "0xc500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217a3054d45c9cdfa16400000000000000": "0x6400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217ac4b0128d8a4e637d00000000000000": "0x7d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217ad6995ccad481571601000000000000": "0x1601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217adc6b87596182a41003000000000000": "0x1003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217b06f1c98f5b75e71000000000000000": "0x1000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217b22fa3b957e62fcde00000000000000": "0xde00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217bbc449bbe44d1386203000000000000": "0x6203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217c36b843445381b9f800000000000000": "0xf800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217c8a06343ff946118601000000000000": "0x8601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217d43349323912c72d402000000000000": "0xd402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217d88164081ddff3c4e02000000000000": "0x4e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217db50ee987c110732b00000000000000": "0x2b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217e0987af4ba3cf66db01000000000000": "0xdb01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217e268756558e03ca6700000000000000": "0x6700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217e768a3d76eef074a700000000000000": "0xa700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217e83ddcd7fd6d6fbf401000000000000": "0xf401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217ec0eaa2c1367812bb01000000000000": "0xbb01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217ef93c6a4b40722ae701000000000000": "0xe701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217f104065706819c01b00000000000000": "0x1b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217f414cca110b27b91300000000000000": "0x1300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217fee25f1232a391a6401000000000000": "0x6401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217ffbfdbac190e825c501000000000000": "0xc501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218068669580bc1b213903000000000000": "0x3903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218085cee7418c7f0e3601000000000000": "0x3601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332180a1e7faca58d064a400000000000000": "0xa400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332180e6d10c23c40948c403000000000000": "0xc403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332180e7289e7d27f9520601000000000000": "0x0601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332180f57eb1b1e0b209a200000000000000": "0xa200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332180f904c14fc769e94401000000000000": "0x4401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321812fff2a95919eb94c02000000000000": "0x4c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321814e3a291688fde6c901000000000000": "0xc901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321815dd087e3456858fd00000000000000": "0xfd00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332181dbc1f5dbbd7774be00000000000000": "0xbe00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332181f75d1000751b617201000000000000": "0x7201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321821db0e59d3ded058802000000000000": "0x8802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332182232755ec18e6847403000000000000": "0x7403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218242219df68294273103000000000000": "0x3103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332182501075cf2732283701000000000000": "0x3701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218271ff60a5611ab21a02000000000000": "0x1a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321827aeb206af6c509f500000000000000": "0xf500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332182e1661fa43185c78b00000000000000": "0x8b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332183103fd51f560c5dc903000000000000": "0xc903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321834f10001df291f24d03000000000000": "0x4d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321836295d721d6b0f17802000000000000": "0x7802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332183707d0484459e68de03000000000000": "0xde03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332183d2b377dea119895902000000000000": "0x5902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332183d5c2f4317f0ee0da01000000000000": "0xda01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321846d0b870628ca4f8701000000000000": "0x8701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321850dca8b74b65aa55801000000000000": "0x5801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218587319621db5b3c0402000000000000": "0x0402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332185982b9d581909bf5c03000000000000": "0x5c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332185ae5166ddef28d8e501000000000000": "0xe501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332185c340e498b59a95bc00000000000000": "0xbc00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332185c5bca6133e728cc200000000000000": "0xc200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332186018482963be8665c00000000000000": "0x5c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321871067d438f078f7d301000000000000": "0xd301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332187271c8d5598492a2900000000000000": "0x2900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321875306c7c9edbd735b02000000000000": "0x5b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332187bb1572d3bddee92301000000000000": "0x2301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332187bf13ae1f8619668902000000000000": "0x8902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218810eb5dc518eb395202000000000000": "0x5202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321881cbf4fbaaf95941801000000000000": "0x1801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332188a7c830f8d8bc917b00000000000000": "0x7b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332188d5337f8196a21e2e01000000000000": "0x2e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332188da8117dfb94bcdaf03000000000000": "0xaf03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332188e8b21caeffe0046801000000000000": "0x6801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218978510a7cda1edf3d01000000000000": "0x3d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321898711ca714d32b78101000000000000": "0x8101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218a054fe3e29b93665500000000000000": "0x5500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218a0a28433ef0a4425502000000000000": "0x5502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218a3e96be0a3bcf36f000000000000000": "0xf000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218a72715409fa27ca1902000000000000": "0x1902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218a7aeaf0b5e8d3327f01000000000000": "0x7f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218aa60d5397b53f1eb003000000000000": "0xb003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218ac2877b0a6a090f9300000000000000": "0x9300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218b5f30d881c24dd23800000000000000": "0x3800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218b8cac68df9338102403000000000000": "0x2403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218b9d58bf155ff9623600000000000000": "0x3600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218bd29707fa09a62b0400000000000000": "0x0400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218cb631b8aef80f80d701000000000000": "0xd701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218cc95d144a400cb10900000000000000": "0x0900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218cd8184be514a8648d03000000000000": "0x8d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218cdc5ba817b39d711702000000000000": "0x1702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218d3f7ae91d718f454200000000000000": "0x4200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218da13b42a44542f7b400000000000000": "0xb400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218dfbc059284ac1ea9000000000000000": "0x9000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218e20608034d6eece9702000000000000": "0x9702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218e65576f369634240802000000000000": "0x0802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218e7686c030fbc81e2e03000000000000": "0x2e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218e7c02ae93e3a4be8f01000000000000": "0x8f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218e94c3e8492814167400000000000000": "0x7400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218ea00e2e694eeea2c003000000000000": "0xc003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218eae950eb948f8d5c703000000000000": "0xc703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f09480a7a4cbd6d9c01000000000000": "0x9c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f0bf919754318839e03000000000000": "0x9e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f77fdbd32436bb6e600000000000000": "0xe600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f83a0c7f521719a5701000000000000": "0x5701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f8d27852c1f94a17800000000000000": "0x7800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f926388df42f5dec400000000000000": "0xc400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218fa0e732e959e5e01501000000000000": "0x1501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218fc45824979fcee3cc00000000000000": "0xcc00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321906d1ea75b3abbcd2e00000000000000": "0x2e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321906eda5870c6a721ce01000000000000": "0xce01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332190d1d6bf1bb6b9200b03000000000000": "0x0b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332191e53e8de0146bfa0f02000000000000": "0x0f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332191ed104ee5b589fd0203000000000000": "0x0203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219224c46ff6f22c545401000000000000": "0x5401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332192ff5c7c306c130b1403000000000000": "0x1403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321930fbdcbf0de9aedfd01000000000000": "0xfd01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332194a42bae69091f242d03000000000000": "0x2d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321950646a7ad8b98d42200000000000000": "0x2200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219571d8827e7b4473c100000000000000": "0xc100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321957a5b5992c073d42401000000000000": "0x2401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219599a4a217cb299f0100000000000000": "0x0100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332195f2d49c46c4474c7700000000000000": "0x7700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321961536a6bdca8d3c9d00000000000000": "0x9d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321963bdc2b3c367df2dc00000000000000": "0xdc00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332196da2de58783401e1500000000000000": "0x1500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332197418bad8f787e91ea02000000000000": "0xea02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219850f1db9f124713c202000000000000": "0xc202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332198d36b16df8acf017c02000000000000": "0x7c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332198ed111fd62f1b0bb103000000000000": "0xb103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332198f092f86ff393a72700000000000000": "0x2700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332198f1322f369447f4bf03000000000000": "0xbf03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332199119b7cd6bdc98d2002000000000000": "0x2002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332199f3102fcabd3f82ae00000000000000": "0xae00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219a5e8d06d5e5a4189e00000000000000": "0x9e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219a65190b335dc8d83f01000000000000": "0x3f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219aff773c570c492d5d00000000000000": "0x5d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219b399d9112e98eba3b00000000000000": "0x3b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219be61526e15c05dfa103000000000000": "0xa103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219c407e22a00addbbaf01000000000000": "0xaf01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219c4ac1770ecd7720d601000000000000": "0xd601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219c81b8d1187ab8abd002000000000000": "0xd002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219c9d8659b9494409b201000000000000": "0xb201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219ce1693f212fed798402000000000000": "0x8402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219d4fd62469978471b303000000000000": "0xb303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219da28814e4ca3ac61f01000000000000": "0x1f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219dc5fd02c6ce53978903000000000000": "0x8903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219e2f97ad95ae09a14202000000000000": "0x4202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219e4f0f6e9bf1a8692b03000000000000": "0x2b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219e50f357826f45e2f302000000000000": "0xf302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219e686f84d73e7f21f200000000000000": "0xf200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219efe7697b5bc2ba44800000000000000": "0x4800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219f78bfd683725d1a5200000000000000": "0x5200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219fee9dde3abf8f3bbc02000000000000": "0xbc02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a0dc8ef9318991f1a802000000000000": "0xa802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a108aa656a694bf38500000000000000": "0x8500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a11bb227e066e7784a01000000000000": "0x4a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a1325cd6169073335100000000000000": "0x5100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a1375f8d1e9a0f852702000000000000": "0x2702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a13caa6ffd0066b26103000000000000": "0x6103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a1e051b66c93245e3200000000000000": "0x3200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a2428e1186bd987eba02000000000000": "0xba02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a2a2d80749dad8c89f00000000000000": "0x9f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a2e103f35280d9288d01000000000000": "0x8d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a316c502df4357d4d900000000000000": "0xd900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a384e3b95e5cc1121c01000000000000": "0x1c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a415cb2b1c7125ea8703000000000000": "0x8703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a442b46bef000beae703000000000000": "0xe703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a48ddb4d33788ec38f00000000000000": "0x8f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a4a6d4951ab49c228202000000000000": "0x8202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a552af5382a1839f5e03000000000000": "0x5e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a5766ea65a559bcd8502000000000000": "0x8502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a6341a62d99504b01d03000000000000": "0x1d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a65956accff48c9caa03000000000000": "0xaa03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a6c03fdf43ec7ccb8501000000000000": "0x8501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a6f838d506ba1bdd3500000000000000": "0x3500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a776f73c0a3377044500000000000000": "0x4500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a7c125c5d7022d154002000000000000": "0x4002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a7d83ead5f56295cec00000000000000": "0xec00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a7ea5b28732a88a95700000000000000": "0x5700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a7f6d990da69d20aee01000000000000": "0xee01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a7f8030f4d5907e0d801000000000000": "0xd801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a81ef511f33535aa5901000000000000": "0x5901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a883bbb52f32fb46b802000000000000": "0xb802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a8de377e9d95355dab01000000000000": "0xab01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a90125235baff7811203000000000000": "0x1203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a9e14f0aea6c38070702000000000000": "0x0702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a9f8eafccec4736d6803000000000000": "0x6803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a9fbd841cb60dac11903000000000000": "0x1903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aa143f12a44b6231c603000000000000": "0xc603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aa1f8aa6506f32183b01000000000000": "0x3b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aa9b21d0d8e404818a00000000000000": "0x8a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aacaaa023976e9e1b601000000000000": "0xb601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aae8648a3175f5301200000000000000": "0x1200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ab0f4e27e01b9e696602000000000000": "0x6602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ab200f854ee38ae85903000000000000": "0x5903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ac69d31b92b6670cf300000000000000": "0xf300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321acc6c2007c49b311f701000000000000": "0xf701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ad37b33d93c01aad2502000000000000": "0x2502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ad78db0ebdce444c9b01000000000000": "0x9b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321adb9d50b48dd5cec9e01000000000000": "0x9e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321adf84446d908a2fba001000000000000": "0xa001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ae3bd5e58bd267c29802000000000000": "0x9802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ae6eae5a91292f0cd603000000000000": "0xd603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ae7ff53dc243f3edb302000000000000": "0xb302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aee697b633330518ed02000000000000": "0xed02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321af0d89300933caf4fc02000000000000": "0xfc02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321af4ee0531cdae6114700000000000000": "0x4700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321af8e89119099ad073a01000000000000": "0x3a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afb4be00c49b9304a602000000000000": "0xa602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afb784d894bf7632a301000000000000": "0xa301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afba43762858e7507501000000000000": "0x7501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afc9a87bb20f085a8b02000000000000": "0x8b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afca3faaa56d50e56c02000000000000": "0x6c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afca6eb22bebb0152101000000000000": "0x2101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afe8a6056ab2a7ed5400000000000000": "0x5400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b019933bf758a2501901000000000000": "0x1901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b02434ada4ed83d4a500000000000000": "0xa500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b02de844403ec7ea0200000000000000": "0x0200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b03eda99cc2e3f307902000000000000": "0x7902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b0423c60a2c4bc78f900000000000000": "0xf900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b1606abfe4a728fc1400000000000000": "0x1400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b191643e464c8c81b402000000000000": "0xb402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b1c7ca82f48aa91ff002000000000000": "0xf002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b261c28f43e687c7c101000000000000": "0xc101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b269b92f5459bc573202000000000000": "0x3202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b27baec2ff0936169803000000000000": "0x9803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b29c2d17d5d0d0ffcf03000000000000": "0xcf03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b2d01d5604a94c366003000000000000": "0x6003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b33069cb5516fbeddc02000000000000": "0xdc02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b3395bed8316782b8c00000000000000": "0x8c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b3b18ee4bf8dc5637d03000000000000": "0x7d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b3ecb367a17f5408f001000000000000": "0xf001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b3f1f296a4bd40dc5000000000000000": "0x5000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b40d435058c1148cf600000000000000": "0xf600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b41ef3e411d15c920c02000000000000": "0x0c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b4531ae98e9c63c89401000000000000": "0x9401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b50f513ee1715a333001000000000000": "0x3001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b52b3440a19f9dea6a03000000000000": "0x6a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b5b1ca131bdfccc81302000000000000": "0x1302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b5ed311879a0d4844502000000000000": "0x4502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b5f894ed85218cda7c01000000000000": "0x7c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b6437bd9cd04b7376303000000000000": "0x6303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b654caccb0fec2e58c02000000000000": "0x8c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b6c8e0b7759b051c2602000000000000": "0x2602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b740b2c866fd4f014300000000000000": "0x4300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b7487e66d5c9ed6f5b00000000000000": "0x5b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b76fd1db4eb487c7a003000000000000": "0xa003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b8a60e8ff84c76ce4100000000000000": "0x4100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b8f253d2bea2761a9e02000000000000": "0x9e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b9140a2aea66ba0f3302000000000000": "0x3302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b966af519f6ef5333801000000000000": "0x3801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b986dc21e37c17a82803000000000000": "0x2803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b9c399fae7ee24480c01000000000000": "0x0c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b9d090cc94fd2135d201000000000000": "0xd201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ba27eedc6b667ea6a601000000000000": "0xa601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ba39e32be0b1ded7a401000000000000": "0xa401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ba5afc976203fc1ae103000000000000": "0xe103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321babf49f52d726c265603000000000000": "0x5603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bacb31a77fc7b6ed7002000000000000": "0x7002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bb698cb9beea6a8ae500000000000000": "0xe500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bc13fd0998aeba1d8003000000000000": "0x8003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bc79ae2096fa980c0d03000000000000": "0x0d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bc8cd6ab8a1c93673203000000000000": "0x3203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bc8d6bb3dffb503a6302000000000000": "0x6302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bd34e8b2f1862b0ed703000000000000": "0xd703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bd35780f67318097eb00000000000000": "0xeb00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bd4f1ac45707c1f6e901000000000000": "0xe901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bdab5b8c9446dedfe902000000000000": "0xe902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bdcf39641a0061638a03000000000000": "0x8a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321be1a11151ba77b3a1800000000000000": "0x1800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321be874ac539105bb3c803000000000000": "0xc803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321beab8d0d0758b987a900000000000000": "0xa900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321becf3b4388d2f343e000000000000000": "0xe000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bf139f57a073f0d87d01000000000000": "0x7d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bfa9de902c3172952000000000000000": "0x2000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bfd90444d0600d56ae02000000000000": "0xae02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bff6ce998881877fa502000000000000": "0xa502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c011d838e7892cb42601000000000000": "0x2601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c05d379e76764fae0903000000000000": "0x0903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c05fbb9d607f82250503000000000000": "0x0503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c0610ff2b6bf4ccc6903000000000000": "0x6903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c082208925c45ac76901000000000000": "0x6901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c09e89491b7388259202000000000000": "0x9202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c0a8302bb2f1957f7f02000000000000": "0x7f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c0b93a7ad24ac995bf01000000000000": "0xbf01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c0f5658edcc164dc5001000000000000": "0x5001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c128bf1f4e0656aeaf00000000000000": "0xaf00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c15c6467486283f82d01000000000000": "0x2d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c17ae56a6b08e58a3b03000000000000": "0x3b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c1fc29468750ede8cb01000000000000": "0xcb01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c24373ed36eb2795b200000000000000": "0xb200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c2614e453d5ebefab502000000000000": "0xb502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c2dc369c03a6040d1b03000000000000": "0x1b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c2f971839039a7c84603000000000000": "0x4603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c35292ce0100355b7900000000000000": "0x7900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c368dd4c5ffbf002ae01000000000000": "0xae01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c3e8f5f69f6aa8fc5101000000000000": "0x5101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c40282ccb96d2d80ed01000000000000": "0xed01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c48564104a21ee97cd02000000000000": "0xcd02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c4e7d33822eec7f47702000000000000": "0x7702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c521f7c6e9c05c053002000000000000": "0x3002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c584a847d252be3c0f01000000000000": "0x0f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c5a5237644f655ebad03000000000000": "0xad03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c5bef715a0c05b622f01000000000000": "0x2f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c5c08420b23b5abc7701000000000000": "0x7701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c5dba18fdb239d374203000000000000": "0x4203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c60f9e33658f0095b900000000000000": "0xb900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c657f09268fd11064c01000000000000": "0x4c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c670c2874f793a80cf02000000000000": "0xcf02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c69b92b9b02fdabdee02000000000000": "0xee02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c712386623c0e9dd2c00000000000000": "0x2c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c720ad615e2c0a50c000000000000000": "0xc000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c7323e46a5ecc29f0a02000000000000": "0x0a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c7f3b2b1237e1018d103000000000000": "0xd103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c888cc77bc24848ddd03000000000000": "0xdd03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c8a8897b2d198a22ca00000000000000": "0xca00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c8c22f08ec55ff0e1502000000000000": "0x1502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c8cec9e56627141c7003000000000000": "0x7003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c8f3b0cb45a89be81803000000000000": "0x1803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c93e1640a0c05fd72f00000000000000": "0x2f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c94749b0685329c4c503000000000000": "0xc503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c94ecaf6afb5f7647500000000000000": "0x7500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c9548cf1960026def301000000000000": "0xf301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c998fc03229363307503000000000000": "0x7503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c9b28c24949011789603000000000000": "0x9603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c9fc44d5943c6e750e03000000000000": "0x0e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ca1b4d3ae5eef018f402000000000000": "0xf402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ca2805f80fcd2e7b0602000000000000": "0x0602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cada3528e4c8a2792901000000000000": "0x2901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321caf9895a039ab0912f03000000000000": "0x2f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cafacd817f1bb76e4c03000000000000": "0x4c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cb5edec1155ae2a7d400000000000000": "0xd400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cb9871c4ee4bae2ed500000000000000": "0xd500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cb9aac8f91a14d765601000000000000": "0x5601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cc7c4370f2bab4d1d800000000000000": "0xd800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cc9d2e0bf31381a8f502000000000000": "0xf502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cca254008d5f34222500000000000000": "0x2500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cca2e27c3d85a12c5c01000000000000": "0x5c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ccc966cdc6962d4caa00000000000000": "0xaa00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cd6d75fea8769bb88700000000000000": "0x8700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cd74d88d640eb0299901000000000000": "0x9901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cdb1d2bdbe56958c7203000000000000": "0x7203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cdd54c170078c445af02000000000000": "0xaf02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cde0fd7bdd857447e200000000000000": "0xe200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ce2ae2c09cbadb23a201000000000000": "0xa201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ce5e70b0a9efbe824f01000000000000": "0x4f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ce739d0c461a25eb3f02000000000000": "0x3f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ce951ca53cb361b88800000000000000": "0x8800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cf584a1d21b0f41d1e00000000000000": "0x1e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cf7c67e6a09f4ab0ca02000000000000": "0xca02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cf7e9d35e86500839100000000000000": "0x9100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cf9445121193b4f73401000000000000": "0x3401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cfb5015e5bef2b349400000000000000": "0x9400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d08398c0f1b9d38f3902000000000000": "0x3902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d0bb1de41f72ee82e202000000000000": "0xe202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d0c5d26dfa45659c3c00000000000000": "0x3c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d0c871fdf790c2f58d02000000000000": "0x8d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d0e8d1824219296d7602000000000000": "0x7602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d11735527096e571ce03000000000000": "0xce03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d14f2b862c158b632202000000000000": "0x2202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d1dd202a20f729120003000000000000": "0x0003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d203080ad7af92fda901000000000000": "0xa901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d21147f69eecfaee9201000000000000": "0x9201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d215728fb45e20b3db02000000000000": "0xdb02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d283059f0dfcf3928303000000000000": "0x8303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d2947c06e7c67f0ce201000000000000": "0xe201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d2d31b9993c9f73f4801000000000000": "0x4801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d2eaf1804c215f7dbb00000000000000": "0xbb00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d319562e24bb5c536000000000000000": "0x6000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d374084ba340e7725e02000000000000": "0x5e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d467abcb7b32622b0302000000000000": "0x0302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d48d5f1fb366e87d0703000000000000": "0x0703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d53c7e37efd26f2e6402000000000000": "0x6402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d55618219369a9d81001000000000000": "0x1001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d5603149a2a3247d7000000000000000": "0x7000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d5fec0a75f0d9b386f00000000000000": "0x6f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d601ad28d8c9ac539a01000000000000": "0x9a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d6618eae740785614f03000000000000": "0x4f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d668d2412a19d9b49700000000000000": "0x9700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d704c1f36d93183ea603000000000000": "0xa603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d718f6c14a8cc37bb000000000000000": "0xb000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d74e563fab59b3080e02000000000000": "0x0e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d75361fdb5a730586d03000000000000": "0x6d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d75edb5fec9717034601000000000000": "0x4601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d7681490212a36870a01000000000000": "0x0a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d784bc93bc8b41345301000000000000": "0x5301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d7e259a1ccb49a64cc01000000000000": "0xcc01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d85f26ac231f8b5dfb01000000000000": "0xfb01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d888b50e4d5978547b03000000000000": "0x7b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d8bf402699f5b4a8e303000000000000": "0xe303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d8e73918bde17578d700000000000000": "0xd700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d9e0eeb6b3b2f470ef01000000000000": "0xef01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321da2bda9e9a1b0b8ddf03000000000000": "0xdf03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321da70c51cf14f90b46e01000000000000": "0x6e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321da9ff003c18eada4d903000000000000": "0xd903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321db307c23c086e05ab002000000000000": "0xb002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dba812c4c5e1500f8801000000000000": "0x8801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dc12eda68ca517e72102000000000000": "0x2102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dc8b5e1b7d061a88ca03000000000000": "0xca03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dcb8a4a072e595a0bc03000000000000": "0xbc03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dcdc98234811767bc302000000000000": "0xc302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dcdedf9c1010c6614001000000000000": "0x4001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dd4fa08c178fa8d9d901000000000000": "0xd901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dd62a4d5f4172290a801000000000000": "0xa801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dd6cc1900d3f04d14103000000000000": "0x4103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dd7c7130dc08d4c90301000000000000": "0x0301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dda154ccd342115e1602000000000000": "0x1602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ddb3aab8cff721928e02000000000000": "0x8e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321de4533e88951eb7b8100000000000000": "0x8100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321de5b91e5fbef5d93ec01000000000000": "0xec01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321deee352f1087d3027801000000000000": "0x7801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321defdc3f60837ca323000000000000000": "0x3000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321df01298300dfdc4f8d00000000000000": "0x8d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321df15689db8d6f1bd8b01000000000000": "0x8b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dfb70447812c50687200000000000000": "0x7200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dfc448edff971a100401000000000000": "0x0401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dfea96dca0d4537f0b00000000000000": "0x0b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e00bb3fc5efbc036c900000000000000": "0xc900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e0404c62fd1f2145e702000000000000": "0xe702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e053adb8c08052770202000000000000": "0x0202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e08b861b3d7382234102000000000000": "0x4102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e0c0c90749c3e7b43b02000000000000": "0x3b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e0e07c6bec0990e4be01000000000000": "0xbe01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e1212d2ff4a55748d202000000000000": "0xd202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e15dcecee8f603143303000000000000": "0x3303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e180d490b0d7068b5600000000000000": "0x5600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e191e352beebc7ea8603000000000000": "0x8603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e196b58844455f266e03000000000000": "0x6e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e1cbfb770b4db02d5003000000000000": "0x5003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e1d21277d38fc3ba1c03000000000000": "0x1c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e27ceb44fb15d4a76a01000000000000": "0x6a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e2bd457ba6c64d54c601000000000000": "0xc601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e2c0a2a258da3805a600000000000000": "0xa600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e2fce2b1123a53567600000000000000": "0x7600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e31b95415fbdbeaf6300000000000000": "0x6300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e33ef4fcbed9d404bd00000000000000": "0xbd00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e38011acf85b25fbf501000000000000": "0xf501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e398b9a27555d4d7aa02000000000000": "0xaa02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e3bb7f8567b0bead7a02000000000000": "0x7a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e3e2af5f6df62dd09b02000000000000": "0x9b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e416f4dc5cc4c9d44201000000000000": "0x4201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e5d9d06d1ea28a529002000000000000": "0x9002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e607cf5bb9eb13afdc01000000000000": "0xdc01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e6a159928d4b4ec3b800000000000000": "0xb800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e76f732a14c24616b503000000000000": "0xb503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e7e15897f90f8fa59801000000000000": "0x9801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e7ffe8566031eae73c02000000000000": "0x3c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e848a851e9c6139e9503000000000000": "0x9503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e87dcb4f1c893e5c6900000000000000": "0x6900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e8c3f017a056bc910f00000000000000": "0x0f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e93088202793fbca7401000000000000": "0x7401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e9428ad66ec9de649101000000000000": "0x9101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e99ec85932be5b966100000000000000": "0x6100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e9f331ed4e344139e403000000000000": "0xe403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ea02a1af8b118fb06102000000000000": "0x6102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ea56775d670a078b2902000000000000": "0x2902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ea67efa3a2a197674f02000000000000": "0x4f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ead5c5d27602e1997703000000000000": "0x7703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eadd9320b4e415860e01000000000000": "0x0e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eaea1f27dc45ee99d503000000000000": "0xd503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eb00435b4c22caa29903000000000000": "0x9903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eb3c81f73470cd586600000000000000": "0x6600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eb5f6f4ae4efadc93d00000000000000": "0x3d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eb688e29eba3199db600000000000000": "0xb600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ec021c07b719ce697e01000000000000": "0x7e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ec191cb8cc4d9e11db03000000000000": "0xdb03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eccc2f2c8dd2d5ba8400000000000000": "0x8400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ecdc81400120b4750102000000000000": "0x0102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ece17b4d9132af41ee00000000000000": "0xee00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ed5ac52a6d9c37955702000000000000": "0x5702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ed78641c153d9a1e1a00000000000000": "0x1a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ed7d7d0843c95e959703000000000000": "0x9703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ed8347073814ff11fe02000000000000": "0xfe02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eda75273be5d877b9403000000000000": "0x9403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eea5e1a468c6e6627603000000000000": "0x7603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eed40c97f629adf32801000000000000": "0x2801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eff6afbf32a48fdf1e02000000000000": "0x1e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f146bf628fea5dba8001000000000000": "0x8001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f14f143f6fea8eae5e01000000000000": "0x5e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f15f87d893f4fae7cd03000000000000": "0xcd03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f1e694844da4d49a8e01000000000000": "0x8e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f2b752f43231cc821202000000000000": "0x1202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f2cd9a1dd8a547482c03000000000000": "0x2c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f353f7374e732ead9c00000000000000": "0x9c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f3ff6597c9a6253dce02000000000000": "0xce02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f42826367c808e1c2903000000000000": "0x2903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f45193c2634429c5f902000000000000": "0xf902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f477d66ddba32cf6bf02000000000000": "0xbf02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f489994691e69d763901000000000000": "0x3901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f510adae845b0e13d101000000000000": "0xd101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f52b82b5e30eba277a00000000000000": "0x7a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f567943c1e6f8c788201000000000000": "0x8201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f58adf1bfc7b0b59e300000000000000": "0xe300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f5cdb3589da164e66200000000000000": "0x6200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f5d15cf10f2566b44f00000000000000": "0x4f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f600f0f35dbc0f68db00000000000000": "0xdb00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f728885644fe36f89900000000000000": "0x9900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f7bd1583e9a173ce9500000000000000": "0x9500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f8039a8d5352807bc103000000000000": "0xc103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f82a45a5cd194ea22302000000000000": "0x2302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f82ef8c0415812004400000000000000": "0x4400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f8f4e117cc61ef6c8401000000000000": "0x8401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f92987139063565f3301000000000000": "0x3301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f9381bd21c174a701d00000000000000": "0x1d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f93cd8f8c8882ab56501000000000000": "0x6501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f94eaa8b35b7276a0d01000000000000": "0x0d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f9c93a8474325e6e7103000000000000": "0x7103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f9f93a24c5b38297c301000000000000": "0xc301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fa12994430ad6d0db403000000000000": "0xb403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fa48a1dc4a8bc718f602000000000000": "0xf602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fa6fd76e3588a74dde01000000000000": "0xde01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fb0e17fb52f37b65cc02000000000000": "0xcc02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fb3a8211b5c332951603000000000000": "0x1603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fb6f484b36a70388f101000000000000": "0xf101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fb8f3e7cdf66ae598c03000000000000": "0x8c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fca206814d26bffc1301000000000000": "0x1301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fcbfbbdb910032c0a203000000000000": "0xa203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fcdcebe9db90331e9c03000000000000": "0x9c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fce2ca7ad3e1fbee3400000000000000": "0x3400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fcf31ac4d85d61bb7c00000000000000": "0x7c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fd1a4b8e952475b75900000000000000": "0x5900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fd228552f5305f261402000000000000": "0x1402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fd36076f8dc022354003000000000000": "0x4003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fd54662142ba1a765800000000000000": "0x5800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fd59d0ec3d0a81593201000000000000": "0x3201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fdafe3f18724a4265d01000000000000": "0x5d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fde43b928ff5cafcf102000000000000": "0xf102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fe7482f9ab46f6fab602000000000000": "0xb602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321feadd3a5082978874503000000000000": "0x4503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ff660b590b6d0850c600000000000000": "0xc600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ffc674f174677bd49303000000000000": "0x9303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fff494a9f86631e3bd03000000000000": "0xbd03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", + "0xdc90e6f82b1c3812e102a180b502f8a04e7b9012096b41c4eb3aaf947f6ea429": "0x0000", + "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000" + }, + "childrenDefault": {} + } + } +} \ No newline at end of file diff --git a/node/src/chain_spec.rs b/node/src/chain_spec.rs index a52ac4c..a428f7f 100644 --- a/node/src/chain_spec.rs +++ b/node/src/chain_spec.rs @@ -3,13 +3,18 @@ use xsocial_runtime::{ SystemConfig, WASM_BINARY, }; use sc_service::ChainType; +use sc_chain_spec::Properties; +use sc_telemetry::TelemetryEndpoints; use sp_consensus_aura::sr25519::AuthorityId as AuraId; use sp_core::{sr25519, Pair, Public}; use sp_finality_grandpa::AuthorityId as GrandpaId; use sp_runtime::traits::{IdentifyAccount, Verify}; +use hex_literal::hex; +use sp_core::crypto::UncheckedInto; // The URL for the telemetry server. -// const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/"; +const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/"; +const DEFAULT_PROTOCOL_ID: &str = "subx"; /// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type. pub type ChainSpec = sc_service::GenericChainSpec; @@ -70,7 +75,7 @@ pub fn development_config() -> Result { None, None, // Properties - None, + Some(subsocial_properties()), // Extensions None, )) @@ -124,6 +129,57 @@ pub fn local_testnet_config() -> Result { )) } +pub fn xsocial_testnet_config() -> Result { + ChainSpec::from_json_bytes(&include_bytes!("../res/xsocial.json")[..]) +} + +pub fn staging_testnet_config() -> Result { + let wasm_binary = WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?; + + Ok(ChainSpec::from_genesis( + // Name + "XSocial Testnet", + // ID + "xsocial_testnet", + ChainType::Live, + move || { + let root_key: AccountId = hex!["a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45"].into(); + let initial_authorities: Vec<(AuraId, GrandpaId)> = vec![ + ( + hex!["d4f4482d82913b5a4ef195bba7ec5567ee04b6ea784139c04ee5e77530670149"].unchecked_into(), + hex!["419c48625508cc74c8c125dd0132158d3583b479975e516c3c2cc1457d11a7c5"].unchecked_into(), + ), + ( + hex!["640f97526d653b620d1ccbdefa4cb212cc0dfc76f77a0f631f96f009d986464b"].unchecked_into(), + hex!["b553650f5032ecadba5df3bd35e8d280bc6f5cdff1beda8c504d6cfecc89c63a"].unchecked_into(), + ), + ]; + + testnet_genesis( + wasm_binary, + // Initial PoA authorities + initial_authorities, + // Sudo account + root_key.clone(), + // Pre-funded accounts + vec![root_key.clone()], + true, + ) + }, + // Bootnodes + vec![], + // Telemetry + TelemetryEndpoints::new(vec![(STAGING_TELEMETRY_URL.to_string(), 0)]).ok(), + // Protocol ID + Some(DEFAULT_PROTOCOL_ID), + // Properties + None, + Some(subsocial_properties()), + // Extensions + None, + )) +} + /// Configure initial storage state for FRAME modules. fn testnet_genesis( wasm_binary: &[u8], @@ -157,3 +213,13 @@ fn testnet_genesis( }, } } + +pub fn subsocial_properties() -> Properties { + let mut properties = Properties::new(); + + properties.insert("ss58Format".into(), 28.into()); + properties.insert("tokenDecimals".into(), 10.into()); + properties.insert("tokenSymbol".into(), "SUB".into()); + + properties +} diff --git a/node/src/command.rs b/node/src/command.rs index 5416000..6fb063d 100644 --- a/node/src/command.rs +++ b/node/src/command.rs @@ -12,7 +12,7 @@ use sp_keyring::Sr25519Keyring; impl SubstrateCli for Cli { fn impl_name() -> String { - "Substrate Node".into() + "XSocial Node".into() } fn impl_version() -> String { @@ -28,17 +28,19 @@ impl SubstrateCli for Cli { } fn support_url() -> String { - "support.anonymous.an".into() + "https://github.com/dappforce/xsocial-testnet/issues/new".into() } fn copyright_start_year() -> i32 { - 2017 + 2023 } fn load_spec(&self, id: &str) -> Result, String> { Ok(match id { "dev" => Box::new(chain_spec::development_config()?), - "" | "local" => Box::new(chain_spec::local_testnet_config()?), + "local" => Box::new(chain_spec::local_testnet_config()?), + "staging" => Box::new(chain_spec::staging_testnet_config()?), + "" | "xsocial" => Box::new(chain_spec::xsocial_testnet_config()?), path => Box::new(chain_spec::ChainSpec::from_json_file(std::path::PathBuf::from(path))?), }) From 573c1d6fe785e820ddcdd3ce55a3a3bcdc4faeb3 Mon Sep 17 00:00:00 2001 From: Vlad Proshchavaiev <32250097+F3Joule@users.noreply.github.com> Date: Wed, 8 Mar 2023 15:46:26 +0200 Subject: [PATCH 08/13] Update dockerfile --- Dockerfile | 64 +++++++++++++++++++++++++----------------------------- 1 file changed, 30 insertions(+), 34 deletions(-) diff --git a/Dockerfile b/Dockerfile index c62bb71..537cce1 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,37 +1,33 @@ -# This is an example build stage for the node template. Here we create the binary in a temporary image. +FROM dappforce/cargo-chef:latest AS chef +WORKDIR /subsocial -# This is a base image to build substrate nodes -FROM docker.io/paritytech/ci-linux:production as builder +FROM chef AS planner +COPY . . +RUN cargo chef prepare --recipe-path recipe.json + +FROM chef AS builder +COPY --from=planner /subsocial/recipe.json recipe.json -WORKDIR /node-template +# Build dependencies - this is the caching Docker layer! +RUN cargo chef cook --release --recipe-path recipe.json + +# Build application COPY . . -RUN cargo build --locked --release - -# This is the 2nd stage: a very small image where we copy the binary." -FROM docker.io/library/ubuntu:20.04 -LABEL description="Multistage Docker image for Substrate Node Template" \ - image.type="builder" \ - image.authors="you@email.com" \ - image.vendor="Substrate Developer Hub" \ - image.description="Multistage Docker image for Substrate Node Template" \ - image.source="https://github.com/substrate-developer-hub/substrate-node-template" \ - image.documentation="https://github.com/substrate-developer-hub/substrate-node-template" - -# Copy the node binary. -COPY --from=builder /node-template/target/release/node-template /usr/local/bin - -RUN useradd -m -u 1000 -U -s /bin/sh -d /node-dev node-dev && \ - mkdir -p /chain-data /node-dev/.local/share && \ - chown -R node-dev:node-dev /chain-data && \ - ln -s /chain-data /node-dev/.local/share/node-template && \ - # unclutter and minimize the attack surface - rm -rf /usr/bin /usr/sbin && \ - # check if executable works in this container - /usr/local/bin/node-template --version - -USER node-dev - -EXPOSE 30333 9933 9944 9615 -VOLUME ["/chain-data"] - -ENTRYPOINT ["/usr/local/bin/node-template"] +RUN cargo build --release + +FROM debian:buster-slim +COPY --from=builder /subsocial/target/release/xsocial-node /usr/local/bin + +RUN useradd -m -u 1000 -U -s /bin/sh -d /subsocial subsocial && \ + apt update && apt install curl -y && \ + mkdir -p /subsocial/.local/share && \ + mkdir /data && \ + chown -R subsocial:subsocial /data && \ + chown -R subsocial:subsocial /bin && \ + ln -s /data /subsocial/.local/share/xsocial-node + +USER subsocial +EXPOSE 30333 9933 9944 +VOLUME ["/data"] + +ENTRYPOINT ["/usr/local/bin/xsocial-node"] From 5d3bd8c94fdbb002a0bbbe0781ad9a9c673988b1 Mon Sep 17 00:00:00 2001 From: Vlad Proshchavaiev <32250097+F3Joule@users.noreply.github.com> Date: Wed, 8 Mar 2023 19:10:38 +0200 Subject: [PATCH 09/13] Change block time to 2s --- node/res/xsocial.json | 8 ++++---- node/src/chain_spec.rs | 9 +++------ runtime/src/lib.rs | 28 ++++++++++++++++++++-------- 3 files changed, 27 insertions(+), 18 deletions(-) diff --git a/node/res/xsocial.json b/node/res/xsocial.json index 70015cc..9932900 100644 --- a/node/res/xsocial.json +++ b/node/res/xsocial.json @@ -9,7 +9,7 @@ 0 ] ], - "protocolId": "subx", + "protocolId": "sub-xsocial-v0", "properties": { "ss58Format": 28, "tokenDecimals": 10, @@ -25,9 +25,9 @@ "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545", "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545", "0x26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439": "0x01", - "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9cb57c70ef83699051944b7b796a4ca3da8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45": "0x0000000000000000010000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9cb57c70ef83699051944b7b796a4ca3da8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45": "0x000000000000000001000000000000000000c16ff28623000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0x91011c78736f6369616c", - "0x3a636f6465": "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", + "0x3a636f6465": "0x52bc537646db8e0528b52ffd0058f45204ce2ec5f90f511050cb28e980ab600770765c2f1cb3571ce015eb05ee187d81169492ff6097e33a67816ec46be891e48fcfc9170ad0f5b823237d2edc8f5d033914c5d96df1be53cf9c31ea23364bc86e8410b2f7965b063f10f80edc10ae3725840afa864ff170ba962f83af22740d9985b0bf16c973effac3feaabfeaef58f5ab7a7fd59ff5f79eace6760ce2247e985fdd55c78177cd8d0353503d5a159cd0f5b53bcb4b901b0f1749f57d5c24d574814f1105cdc3a7f8d55ebd6cb8fe7c4a8f3f3d1ff9f822dc03f9743dfec822f9ee5c8f9773639deba579b1ce25e47a3e37ac733dfe867bb0c72f1e5d5de878218bc4757c75fd65a9e6c6ebef5adce8227cbace77bf8e63fd35378e458b5c99b6be292188e84d092144dff0e97a55041ba3cba72beece7e35b83bfb1faea66b2446457e58c8e51eeb1dd2ea1a66d6741d95c4c3739c45ae4c9277f822bcac46c33bfc7548ebd5d0bad38a78c872021f92baa88ea00a5628d3d5ada0baa256e2974f16adf01c27d195e5043e74912b5379608dc9452b0f723525f1f0504b527d77a7466bbaae66912bd3ee3108529c25eff0ef900ef1212dc2d2f53547c75fa475e9b420f9ecf1d7d4be8b64e6d5e5cc4c82ea9a5d7eb524d7ccd0f57d36eb7577e97a53422475dc9d8ab524ccd7e6f5d2742de56a34f031ecdac45e9aebbe5a10462bf6c5a66bf91f963bb3cbb92d5753b2b4bade67979c4925a5dedda97b295d26b3fff066725e33e3d3fb05b6ecf2a5aed792ab333a849de5acd8dd7fde6a4cf898d38a5c992efde7fd70696e6373fbdaae669c70423e6de65e137267d8e0eb4dc7eb08f7449e8e8f7721fe464cc717611f068a317434d2f11bf7f0638cf19b13e9d0a690e4aedb7539c88d34199fa04d0ddc53bf05a7ebbad1f0f1d615df56f5ba62dabaf9e19e7ac9c03d75d3817bacc7c03d43daba13eed994162dda3a07d80702bd15b363b4f5e51e225d6dba1e692bfe878b489e1618b7465b979cf1e4bef9415b97cb6edf4c912bd36bdd867be02debd637c7a2434be67139714f1076b07bbd29b2a9669b77735304b28f037adf9e4d2b91fb98d86ae6c52d921cde240e1be4d3d22f9077386fa614f9be39755341f0f15ef337ee79439affacebd639199f6e2ab07b4471033151d822054928016881d0b853ff08f7d4ad378502289a6f847d18881fc39bae3716d2fcccd1ac3785822d0de90d9fdca6a82077021b5fdc9311406e928d2fe50ac18b1464704719241ce104a0d5a4fbe6549ee9a4837c72909b403e49b99a928ad677f56b230de413ad47aff41bee917f2fc23d96b4308c56eca56356c6a78d7b2cecefd29aae25c6a7ec4e5312a4335ab3976ecded6c1ebdc62e1daf7b33d6dc9673bb84ddb4fbf57c8438d0b2ceee4e2dd28ed6eaf1eff23957cded07b85ff328b6cb24673c74f59df57ada461af795505b8b26e3530e9fdeadf3c9a23f6f279cd5f5be9a47aff76e6e7ce23b2d6869a4179f78eb5fcf07262525252501bd9f16c9eb97d325175fd0a50bf9fe26d0e60e21b0d52b06c1a5997fc347f38bc479c327578bb4fb6a409b730d9d15b92ce566a8476435b9346c9b02028f8ebd29208ae8a521e3203c923ddb3b99a473c0b69a04500d21bda87311e002024fc88c796f97cfd99eb519503db4b408a9f795bf391d6421d39bca027f80de5496291aca6a4a17b519500d95b8ae505dd18b676644bc845a507cda0ca87eab55ffe18b7b702a9ac475f58a5e7c725fd79b03e9d0d684ec71afefec66c684739b44ae03b62a3e3ed377182b25fcf71f5eeec149c27f7f558d1f7a87afaa5fdcc35da5e43a60838e5e7c82879726178a901a2ea41f90cbcf7471cf3b1f7eb9074ad682a0d36640c1e97ab5c701b9dcc32fdb29b7001becaca569e195714f842fa2dd3472cde7bf09bf5a50918b7353599ae86d9e6f6ec7a9c12cce4d0191d4cb3d0cef7e718f6b77d6825cd6ab2581f4d18b270a3a4786dc9c1ffac89a877b6a0ce79e7a8a817be0df8d708fd5ef1bf76cea873cfadd867d18e8e5f4fb728fd5d5857e972e5bf6d99ece42ee19e2bbdb700fff7dd9679fcea3593e657c7287979cb967eecb3e0bb4cff2e8bdd3f8ab25e1c32fe1c38c7b78536a7c73aa4b6adeba6d4a082dda25f9bc6ce706b6a1f7edea92b83725c418eddadd694d9c0fbdb4ba24f89d5760efe16462eafd9bbb482a3cce9252435a64eafdc2d13c5db74cd777de9e563677d7cb2fec9d56f4a2ad1f75490c46ee0c1bbf5efddedffb7bef046ef47befbd9c4774022fe71e3effc43d1536f373523ef4e1f380d808772dd2fce553e1b1c0b6291fbee84df9b044d753f317d09b4a1ad3ab054160abdb0f6fdbd67c8eefbd8c73fb4dd7720bb0b9ae5e166775a705bdeaabcd80ea4a3a6d497c456b7cbc646dc9d6f1ab413ec14b98bde95abeac9af14e5b3e559b769772b58a5654577fb35ef1efcd0abbfa0fcb376b04fa5dae66d1ca435b7fb36eaadfe3accb271eaae800c549bfd7e553ada1df6b94a1df7f5e9cdbd62c7a65ca94e1a3e3dfac3134bc74d99bf0716eafd6c4ea57cd22ab23adae1f2d7265ca9429d315d5ef702e9f1c857c72e7e91d00aa72d007b9019861db545298bec0f43e631f07b4bfe19e4d2535d1fb22bddf9c7d80dcd3e6be5f4ccae59e75edbe97a6e59e85dcc3df4b2761b6dcb35dafdea581c01976f069fbc1bff39f16c4741d0d04cec8834fdbee6f2ea44e0bbaf8f4be9a0cdb4e0be2ffb03b436e33df31d345393783747713025b2a29a92b6cfee57e5dfb7c9675ead6ee756be81c0ecf3d76ef3fecde7befb9bfe7987f35531c267c78764bdc9956fe63e7c2c8cda96fbe5c1636b905d8f6efab05ed9d968487a4a4241f7ae9f2a95ecd979c2df7b873cff289ffc36f423ef109b0c1df70cff6c63dcba73ddf867bdef937dce39abf5ad083f38a00da0aea6af7ab1dc561e20eef0ee991eb47570b72b4bacd613af4de01a09e736ac8edcda95bf3e5c53d954866c4e65eb366bab937711f7af4e25385bdff61e9e66b2d5b24466e4c5fc966a4cbdc849d91e922abafd468d98c092625b5db45e25edf974ffb8b7baaebf7bd7cf3e2d37e6eeffbd594403eed1fbdf8b4ff61c9999bdcd9223172a9be52b53b5f5b24462ea98b1ed0ee7ca735d992da3de39e6dfe6a4b5c52bbfff00ffff00fef5c3eed3787e9d0d63b00143bae432ecb7d2cd8dcf75b9255d8e19247491ea1c4460526d671152183903790595468c828a4149716c6c3b203ab81d4228b9065a411a536ac26543fb082805521555085714d7030602694de280101a3816b41c506c6a56ac38a432e412ec149c82638329209f641e651724322410e61c121e1c0deb8aa905daa265c7d6041700b58052c478c42bc82ebe2bcb82ea4126412621e5619d7098e2e35a410b209c902494605876c41290ee982cb08c9042986d4a34a6387ea8d8b08b947a586740217c112c30a43927138a8caa880608df17cb0be58605829868155841211e418120f0985ca8d0b0525275846904f9028905924104f4b5505eb0e49443c825c41a90e5e42340287713ba8d6a8765075516d517151e1a0ca4145866cc3f28195866506160736042c08d7964b055712128c6443fa00bb02cb02b301f6c315838bcb15859481f3819c4125e6fac105848b0d46a3fa215621ea11a510a110f78873443c2210e21bd18dd8460c420c13d7883f886ac43b980ab108d10e9e83a5108510e360265e118f887783378347c54bc153e225f1b63c24de11cf8897c5c3e27979367857bc2ecf8a5783478357c5e3f29e7852bc28de0b9e13cf05af052f060f8a0783778207c443c1fbe165e129301fdc04760293e128f01afc0597c13960307c064bc15b18093e828d7043705670577065dc1438c931c1e5e1965069714e6033dc1b4e088e0e070456e325b91e3833dc174e07ce0b9783c886e3e26ce0ae7055b81b382a9c169c867b8173817b825de09a702c887d4079e2810e70c08608fc48e90a5080c912191ed080186018c10e12061cf17961010a48008f912b03788e0024c06148d7eb601d183f212b513ef0a44a14211d9e3c91eee53045e8c99312f6040ff60222a2283810114581800ee6c45a219212e548288727424220600173c15201c114294f486024b443d1132955fa688a90084810a586632d58211ca65099f224ca1329555a0887295426703465072a38e0d000c058b020a042c5a8ca932a5274b06224346504549e9040688805ac89cd41684a08a45899b2c3131ca85c91b24391d09323232a55848c9e1c4911c10776b0720463627390f2e448c88ad10e380cc15610822a394c8962a42400980a72a08283500e02c096582b24101a7a62c50a0984984ca122c58a15210b4c2c056b4548ca9114232a3a1ced10e507a6c44ea122e5288ad10e393c39a24264e589942a1dc56887068225b1237842e589942a6d24346444050353a444d101071080a0c9c4b6acd051941ca41045b9f2446807a11d2860430e42210841141b0e8021b156867010d2018723d6cad1142123211da6483966c4142920c0c18a581ca4589922c5e88807a1272420aa5225ca1323a11c88a4ec003484031522a02218112b8227518ea2e410e54888061a6c881248218a22e548ca14294030217608072a441f782274b4030e423c08d5605ad6880a04b27542441f8872346507103c39c241c8484a0e53a43c79328448c586e5458c34a6e845c94d2525b543bd21157fe12fae8ab360104b8810215610082384fb5e8c70e57b0c9f0617967679d7bddd750b21346d2f98b6dd5de85cd016c0f0c17d5b8470173e081742a929e0c783efbd04bc1f3c258e102edcb71083abc1dd6de1c5d5e0561156ef3d9bb78fdf836bda65b89934d610b0a31979a51f102e94eb9c8b5b6db50b67660eb010eee3b70bb5270db09ad48170e1c6991978ca32086126b32c8b32835066328332db0cca0c4a089f84b054da7d1042a8c1e55df816eeee7bfbe0eec61823b41e64c7fc1632c385bbeff13e68c5b88f2df82a8695e9c5aa04df46f9dc3e08e3328415cd7b17cdbb4a0fc6b80b217c8f05b8fb23c607e32b2dbf588a3196207c8fb900105a313e8e701fe4e585909921f3db65b80f427e90e12e8cbb1be12e84bb716110b8bbcc1b63dcf71e840c1f011e84707721843938a5d28b25e72c1c6b8b315a310e80ce676d6c9562fc830fc618637c0f8815e3c6ea319bf831c3b7f141082bc8567c302e945590567834cb2430a2220221115402c841c8482807232a4f7a5e50809014a32303b060636508905500152a4644867088f20122222a4606084014212322448e844230a4c6ca9115293c0855473844b132258ad1d19323292210019513005601524020645485ce18451122c201c72687294255aa44792214822846548eacb84d800802b042424620786244e5280a0e548888a210d9048840cad1941d8ce80c088e7600c00c0f423a3c399a22c5a8ca131cac48114111177a00c00395111c05a0e70505bc66137044010978a200a1a128441f781282295274b0124587574746518eacb0a000232b04c05601390859b12264544504547078622474850a0e42464fa258c90107a1270918ea794101557010b2e273e980c351940f3cd1c18a94295240701a420210483112ba32801ba1a3284642538442f084010978e10505e420f484ca51151218e140808b48e88a10d1131ea288400057a608bd229b802753a848b1622474e54908a8103d09c1142921080115a227473c080db93245e80900db0123315209097541595485425548480b65915048280bcaa2502854ac9090209445a1901e946528480e8584f4a020392414ca8282848462288b84848484848482509090500f0aca21392828b7a80aca2239288b84844241288b4262288b846254848284720b05e5160acaf183b228140a05a1a01cca41599483d2c35670bbeb446025ca0640406c7e7ce93e1d2e519a490590ffb0d9829c697edcf0c9fa316df8643dc83ceb582fcd139f6ae636cdff7c80d09480cc8b75acd3cc8d4fd6b7c9c327eba6e9029faccfcc08f0c9ba3665e093f56ccec027eb72d6b03bd6f7f91c611dcbbabbd3927097e8f2c9ba7e709c81462b8f1b62168d5e5ab56b443c3d85a787b2972a4fbb9ad1cad3d9736cbe3ff7d07c5f6dfac76b68660c7ce2db4c1758e707dda7232fbfd5cc3f1d7753cecd8ca67d7b3e35dfceaf99fb7436476b669af5ad7d66d6ad359ad5d043d6af7da88da10b2c5a4f6dedacdb8cc65c6cd72673b17d669e9e0eff7a3e3367b669ebd9977d32d6b1accb226d7d66eed3b1eeb4208d5e7cb2fef3b239eb4d3b5a6d2646333eed2dca55483ed256afae2aea3223b61da35d96ed3a9478bedb32c7c98da371b3636c31f8b8c03af1d6756ddbcdcd7faa3ba679f814b769cdea96e88ada502a308c6ecae26785748ef93d086325abccddd2827ad8966658b6a5950362dbc799bd34ce9e84a58855d975f169e1f51edf8722bdf8b4ebaede5d6ba6f2d0b0afabb7d701959600e19396ab86ec4e84581e84d97be08b190f67ee5a445a1c2801514ec3574e5e191413c486b7b420f8227cdabff7de5a55848fdd5e3337bbb3afe250700463b52ccb82553d7a320b0f2e5bd6b2b4cad0471ade256dee44477a777760e4049b3b7cbb3bf5d4cb9056d4170dffde519bfb23da311a3a2d9b3b0f10fe7d21bf61baba506df8679138d91d77edf53df37ec408fb9c9ececbac2fe4eb17ddea56a2f5ea7ae2c12e39a7b1b3c6a4046fd0e08d2d4dc4e3c60c7c0ad36e667b3a4e73d974ad1d39f27c4cd89f8ecbb0e763c33aefef36d99d115b3dd2ef27233c479e4f962ed7833890e9ef11e01eec57cff57719b8874bc79ed15a44d2fa7e25f94774a4b13f8d09161f28318597265a31a5097b358cba9bac79c485c9b8c2c1e552ee623abe9e7cc0ec6fd84786a7137fe4e9c4ef97d9d8209636361663dbbb26b887cff4c8759013dc63416105f758940a2fdcd305f7e0b02ba2e3b7adede9c46bebfaae4b86c225c35c6cf132385924446c75c7743c941cb8e77abc0e4955180bf754a2533b1e66b8685d379e1654d123e8b4d89d787ea1dab435998bcd35c1af17ad5b57d7c44df31dad37ed86d8ea92e9f8ea9ae8f82a47f5080f8e8b6be2f964e9021fc481dee3dd14dc531d14dc031f1f03f738ab673b5a326c5f9468c760620219b081c79826da31ed605713369c0bf905771bf659a00b28d6ad23d03e9ff7e852161212663cd42b569359b0f13b82edcecf1c1a30c6b8afdadddf5cdcf38c58ebf5bdf7ace53955e7c7596f7aadb83bf0efb96a569bde386bd67bb9b03bfbc8849fdd89e10807721adef94094e3c2fe94c3c3b9be880b62737f77db8f904f8e567948e8ced37d8630cd631e75b3f2b473ceb97aea19f8c47f938867ddf871b4ae9876df31fa480cce89e977471bcc113e319c9568c7f4fb941dd3438ea2a07b3930c2a71da339d0ee7b2c558e6a9126cae9e58d4f368ed623ed1e7f32f2434774e466c7a8dc33424ab9e7b9469a799a8f34d75b8f391dafa0ecba7e9828a7f77039673a177a8fb8bda9950d9faa9b7755d1384fcdf50ca1db38b3bb03f94474a4ddd9a12e17e1807f6ff7f1b5aaf6d57ea8dafddbc7c3e65e61f3d5ee88cdddcd21955431eec66ffcd0c233ac47afe361119bf80a2184b442e978384db0b9c3a3d831d2e55385af310e4512400a5f744f0ab9dc535f4b66667efc1805925fdf7beff072bd8be475dddd2fecdd9ef7cadc4346dcaf4c995d18e0eb7bdcae879e91eb23ee65b265cab8de45f2be92e7c5828d5e47cce401bda8e7de12b23725c518b137e54498be29f274f6ab6d02209c1bd886e059e81a5111a9e12b46c316a123a5e28adf793d4e38e3c3820cd04593568d2df015ebf79f07270b2ddd6a1a60a1911c2a32b3218b5c73124e74f6789e565cf35993611ba343ee181bb9dd893fbaba68cbb43c6b49b2974a92ee70d347371d192382cf9228a2b3639732665c3ac61a13b8047b26efa63c36b33f8dc975e7e8ee8eab4cddeeb86397b3723beccad545ef0a4947aef9eea8cab112dcc21fa0e5eab0c157dfe24657b76a708244d2031af24edc8353fd3927283a6cd912810050248f8e46b8a7563f6ddceb4f86cc0914ee890b6606ee711dcf83c4171def42843c1dd70d301dbfdc33a4ebdad1f1aad2d6797f54355fc21cee893762a73179d2d62febbc16dd35b2546255a9fabe3aeb3c2f6acd6a56545743d5fabed29658d62d5a7b68fe7645ab6be6f92e1dbf3313575126ee1c5f441e21a6ab199d0f5daf6f0a083e3669c33dd5e3a1a6e47aeda1cc12f78a56f6a1afcbe5a4b65ecdcb9a3faff2a11d3f329711648da1d7c7f4fdc63ddaf736dc53faee8b3c877baeef4fdc531dd5a5a9fd9a2829e57f389b38d7b16b46f0d1f0dae54ea92eb5c825da367544130d2fe1a544b9ec18262f9d7cd16b793984c3c47a84d68cc5c49ab1e4af4bacf46dac44935cc78e8169f8d2bb6838148fd1eada7af66bbac69e96a4542a95e8507c85b7826a6205d5d987aac326f016add5338afde73576c998ad96d18aa5b357b3c2ae6e9a8f83d84d8003ca627a10bb09a8ee807e5e3665ccaaf96e9a0b744d26181dd20eaf7db5a04c894dfbabe42b5ab54b8a236f3d3281d7288ea44cae57bf64354bb786aecb627259d712788cd6eaf252ce9a1d07fbb67c3571309a245e56df3e824bc3cb4bce864a97b4baaed5b3cb979566f6ea3a632d895c22e9ee4e957fc7e8ee54ec4de025ada55797ae2bd7ae2b575d88a1f7fbaeccc1c03ef47e66916cef798e203954893322c0503162091114b1c71043c9d35dc68913bfccf1ae9a38f1aead8d34f02cf4bbf59df1bcd5565b59ee5bb9bf39da4dbe35abffbc6ac69671ba4b1782cddd87974598c598f1748fee4f0b02c1e62ea396642beb34e3e2e4695ebaf189857ea8cabd30728b8c36b6416f6a091734c3a03795441f7dea4d2561c592a31fc874457d5175dd21891ef4de64b4bd2fbda926ee6837466f8a8928da486f6a0566384d49298d315d04a5c93cd14548335d8feaa0e306065d8fb8c040d6d1f588883a62572b716c71002fc274b5d24598de2b2969cbf4bef79c0259e41a5ec2191f231ced6878675a532f98a3e1e1ddd94d1c26118e868f7074b5826af838b78bb64c993215d5fc3847bbcb6db26d4a0a2d7af66cc9194f01749c118e769a925f01e2e8113379f3df94cc9a1257a68b5c99487196b8bf2b717ff4486eca09317dc41d69e55f71fd8eea37fbcdd97c247b8f8a8efb2822a91d752d5df5050356d3b10edba68820d39712ebd8874abf1e9ffd5d56932f6726ceccb72baa679ecd5a55b4c8d4578eb867cedac499b96bd325cc78d6eb7cc913471ef66b799edcab2d7149ac2999b9364dcfe6ccabf9326dc29630cbe642a1b5f95ac62c9b5b85d626b784ec365ab0329d9fcdb5426b1b1dc3191c262b469932cd7f5d515f2425356773e7e86af2ac6e9ada7f9e36e30ef1afbf1950605cdfebe26f1277bed396f0afcb99292f5d363397092d399b99fb84962f9b99bb474b9855537e665ab1fa0a77088c5ccb471f5a5e565a0836f9d540b0412dc9ced1f272e3730eb273d50066e4778ca413f4cce4698995ce52fbee0ea63dc3667d5d7a56cab0d2e534ca34ad7a5692d5b1595d97e8ae9112c5f657ef234da41b9f20a5fde80d9f3467e1402ad99e414821dd12fcddddd91d8bf93b5df3847cb2aeddb1ee2606b6eaf118b0da3ab64882f8d6ad5f8be40ef92edf342db1943cd6b0ea7cfd61bf5ebd775598b4aebf79c5f575dd72cb6fe6bd3ffabee8d075ebabd17061b4a21a731896ebbd77fde715616976bfb8e8355ffc1f8eb2f19d34ed7ee2bcbbbff3c4797f53869fde3552adbb73e6acbfb96dddba8c8eb22a7d7db52550fafab54aac59af0fbd5b97d7a446454b2629a98f6abaf4f78eb22efdfa6a4daa34f61fbea651d1039a77e7fda8ea8bfb1d9b46d78faa2e7d35264f1abb001afb358b1ed06e77b087d15d23ef5a92f8eb9aee5675bd8fb3f2dd5753e2fabdb9f1698fba9c75865c8be6c5cbf82e9dc6079216d38a6a7658acdddd5bdb6e1661696715bd5ecdfd87a5c9d19d155e97dbf95e9155a64c993efae259f4faa2452f7ea535abf52b5b13c1241fbaf28bac3e7c28d357ae8a0dc15f5f5ab7def3ccf857ac22a32b565b41b5a341fb9fb7b33a1f71975ebd448b5c1f0db179c40d4f7196b854bfb316f45ecdadeed5dfbcc215d7eab4166169f858516d39eba2154b5fe7e99899af3b2ba8def38b5e923dbf2a7a0d1bd2a177f7d5984026ee8f0eed79317729c1271cac206dd85823e28b43d96c5824dadb92360ad25d9ab6b3ef97a7b12d7d91b86c7e77787a5f2db9e6f5ebfdb09bdb4e2bc95212cce45aae16b49166e353e9d8e59d16e46845b5c36669ca6b5e715d5d6377f38a6b0cfb35b7a17cecde9b71b4e8354e92d7ee8e7e77f6aeaf89d1a1ebf2502bbababacca4692d9aecf0d89df601eb18dd3b79cd7a1d2bd18aea920b2a495ab1b4bc9bd87cecd6887b95000a8cde35e28efde71561e987bdd22c7afdbed88cb26dfdfec33cb7adb9d3d5bca674d9356bbcbb35711c2d725dd11d2329a90fd096ab6620df96867f7303db503c0b5d237545f0697b5340f0215d11dcb30d2fb4488c789a8a3d6aefb8fb2ead6896207680aa6bf9015404f7d8343c912c89ad12b52b824ff03c46a8214b75f71fcec0565d110d5fd7080d8f65bf3d1d2838810318e0c0cb98a424a0ea10c8cd24588323a43841143b00ca12c40e90bb961f40fb2c413090752d0e0072afa616070061e962833b961a9e0ebc0bd3f0d5b174b1c17a45b1fc3c1d788b62e962437547b1fce9c05794675329f7ba61360a28f001154b08020d88c0c61b3e3b625b20940ad0d8c1134f8421260b3d8016685f791a7e351b9e9404e48ae01e161ade6d61864fc85d24950765ea29c1470891fac52234a4b15616bc45a754b456277a5890e948abd7472b96868fc9aa814457948a2bbe223511ca89aea634204baae32ba495877e53568d2d1d5f4bd0b0a253d68e8e340c171eb400c7174884155da43745c4112d398b930a2c7b24539932659c00c2a8480a4207163f202109de15bd32659a8a240018218325a030220014360093745465ed682a925a80e34bd295066449f190b46a6c01dad71274fc2e0cbb2dd44d09d1833e724dc509d60e208c26ad1d404bb1ec91a63c1183387ce8232909e8a24959929280f615cb1fad5524ccaeb987f39db51b5a80238c3240fbd56ea021021d33b8c20f65ca00ed6dfa71b503f9209cf1ce59578c7fbfe61663c5423c2d3edbd16bf77af45a3e1e7bcdd1ebebf1d9ac3425ee43f2a547ad49d6ee6e080783bb5e3ad6d8a116846d89159c95040d2fd731cf54137cb525b1216cea86702d4424879ae1ed063c3c515c170f2a075944e1250e3ef4d0c30aa06da3af012878180a1e34c49ca1049e02460823134730430860e880891c0041361aa28187168ec11962ce3802197b2863f55ec9a8d1e0cab4a3996b810f35766263074395492bbbe615a6193bb1c1ae198c8bc4cae25c022fba7baad5ad6f5163f29898a0abc75997c0965716af705f9758e6b425b02ff7a07b33f1a295b6a4fa5342e16603b9dbc3f09132adae07eef2c2c0bb46aed7b4bbcbd0311596281e9ed18534c1089db604f6dec1faa0c6445bf20e69e525fca14723857ce277d770912cea395622b67106186e8299b216c4cf69eeabc1c79abbd38a9093b3048439d1075380e1825700460b30351082530089f4a6c024d1576f0a8c10632891c34ae470115298b1451922d0410327a47e50861759860ea00853c61355195314b146195aac32904082b39401853292f08221d4d0f2050c148cc1831ef0d1032d4c040b51c61d65d49146194428430e1e9e20ae8b272787818030a708662441841594f0c31e5ea8a14406851898f14512b63c91441a49f00f9c854f90c327e0030d32ae9064e4a0057a9c41461316193040420f33c8c842461145e8410614c850021f3ed0838c249051471f7b7c01a30a7b8cb1c71859a4400532e82023087b8021230e32dad8430f25f6d0630f307af0f040e1ba78a2f084273c21e7093cbf168ad184183138a28e0688514410756c9bcd390ad129013e08e911b6526f4a0c2ab4bbbb63b37a5362e8d16f31f0208208500c39ba9ee711c173b349580113a8f0c5163a98820a4d28e3cb12aa2f7a145107d00a709084850d9e6082881e7c81c3fa4207127550208d34b87cc10316a8c00ba048c697d4f5050c1275fce84d8901a64bbd293178e084111e1848783c6f075fbc84118612f010c30b31b820c213630b316c90936307843945705bdc0d61eaf0011a5ea0e1041c63d4c14468801841040183a4349e20c6872e34c0430c31be94e9aa8a0111502c980115aeb0822580c1831d00555fea5022670ccf983173c811856c419816400877a0c4d582303da880cc165a9e6085135b8062185fec01bfe0a30561fe9c30b0f81284309e0840184528018029a4a0481d4ce094e102225f8018e285961b2d821032832382a4984002482a88246ca090c48f231c51330711346b18b17d31c2c44511335c8ed05a70440606124448309290283521098c8e242e35b6585f2851d14089c803172001d7e0c11622de1a3be0a389357630a6893576f006116b0ce94dede08b36f5a676d0e553f003ee26bb65886a2fa0e803f4a672b0449f67c4e1dbb084735d0b15ba66d6de776e575ad0c65864b1fb6a5cb916f6703a1e6cf814efb29dce358474f0f0b4715d3c6cace18030d74acf2eb359e54d9f2921b53c46abacdcd833fa7607d3e4b33993d160521ec3a8a46e77305a67667db4a24cb3ba339fb800db1ec08e7eaf71a3dfb74be93228dfaf2a7df47a683b768c56215f8d869afff8b379903f5a817cb5268f6e43dab16b135e2e91bb36466bff711d68d1ef355f42f347abe9ef516bd224bb892ed12e69499bc1e6d91f36abcd25cd8cd86c5e3a643273ec1a0da53f8a23ff4e736ce248ba24bbbce9d87791e030c92e9f5153d51ebf9a0c32b8b6919fa199119bfcb3b9a44336cfe8d08f6b36b444eb8fef5963e296fca02b841ebdae79100a81d0a3d7dbb11a5a5d6fffe16d56a47eda4b97a5e9b425312be5d0d9ebd59ac07e345479ed250af9548f5e6fb4f6d02f935ad0f53799068d423e952e69462bf6a3d7af84adb684fb4156637be729a6e899d2759acbed5a93ec368f665654d3dc6949683e535d4b5a676ea299953bbb0d7dbb23ffc3a6a99d66be2e9d666ea7b989f2eec897fec3bb484c97a799d5b5fc6a4d32babb236fa2eea2c175890e5dc7965cd79cb936f7dbacd87b68ec180d589766bedacc22c92e25add50aaae56b3e54f3ebda335a91ba5679ec999c43f2db7289dc311d2cd1d895485a915afec7b559b9695c9bae9d66eeeed8dc64a2557e3bcd6de6ee0e0dadaeb5ffbc1f73e80a5df3a725715d43afb82e416d0977e94e63e266e850e9d8b1f7d0157b669aa1995a9212351dbb36699ecd9999b9a7991badd8ab9b26774595e690f626a517b9322dafcdd2ac302b4dacab76ecaad82da4be68dd632f95e8f57a68a4de477ac5b503d2ee419ca90f135bd7d3e1db9cb1559b9b5be7e758e79f16c99b6f1383a213b3b95b3146388bf0897f5dfe70f57addba356f7eb0b96fd79b9b77784787aabf5bd3b5e51e0a7ead1c55f54210d650c1194600228d216c3761a84cb1e5cb134120d103183ca08ccde602a3eb76eee30b3b74b04710e2f042075ee0608d2468d122084b0c9146175b38c00b2ebcf052d35abf1681ace3bed5d43c20c2f8018b305a4e90e45384882c318841d2144f6801e26f0b430c2f68beab6907c756b7d69aef1cff87103f8411668c13450001c4bfb6c7a5e6a0c1123da4596bc752a491461a69a49193c6d13b7a4260e7227c35abb424ae2b8aa3041ed5d5ac5a92f757b916de51cfb930120778f47b535c28a1e5ca97ad96653c1363367f5ed1ebec3fcc5a5006b56b87f15a931fb6d9315aaedc0c6a411aada8d6ee66fc420743759ba705c59ff7b4a0996b7386565467ce399b96cb3d197ddb70c76837f765ac2d91fdf3a4095e4cb3d09beac24b1750e0808fce41961ed29bea028f962f8b2798f3ce455c4307c376a4367cc25e6dba568f15f611578c1e71638fb4da347cd492b876afd9b5eff5d2ee4ee4c76b333362cb5ef725ed4e5332641d7646879666279231b159d75eb16bb45eb1e12b07c34587b0674cb28ab36374c87aeca735896dd1cab5f08c569b8eaf5c0bf14efeb06b6d89ec48a5745a92ea5b61d7ab29808e318900da622d89dbc733354a578f13fbcf93d835b36d771c16fabaaa47dc956b011e3ece8a2a7a91a23257a24203badef85c0a2ca4a0820ebe74e1c516403100cdf1441c50bca04b1e2e00727fafe6de2cd0a2881b38e17e5e1931463b50c062d8dc74c1dbf3d9c8051d1d6d1e638c5b68793adbd081e1220c1760de0bd29bda828c2d524c6869baa9fe45b262f8fc68917a3adbbd57482209779c5145114b6c01aa60e84a0b305d69f18611633010c8e095021870e8c08d30684006159054e0cb972f6080919313068439ee064564e1040fb260c10fa92c5490259585123fa44cbda92c7e68ab3785451f29b9dc0be5728431422aa93e6a4005163c810b9917aec802bb42072c78db4d149bcdb62571420b3a74f0441a3ca8820b576457c020055b90de14163c80c2afe8168b07df835e8ed86ede7b584cd1af08a0f7fef7de7332d8667a5358ac20eb4d6131041640dc212b158f2275d977192222da339dd2ee488c729c445edcc33c2f77b7ceb98962e7ccd8d9d9d9d92c2a5855f4397c7a021629114f5755555df408d2870b5eb1aaac18d3951577f810c5950128d488821941fc0008632c008b2c969025f426848aa3117878a4b82e9e9c9c2920ccc922c98e2b860073052ec0c082a7cb1d589726c4208a0208018b41106d94bcfcc0053c375b165dce38220a17bf6010c2a33dc64062892f92f0228916ba50a175d1e28828baa460a64b0ca278ce970a0c536fcacb1239d5661179ee002158d046aa0959a0500208010dbf55a161432baed0500540f039275a1f25e289e2027236bd292f57b4ec4d7991420db939158669bea3c156f744f895b98c793e151e8e4ce5c23c9d8af6502589a9f818a3c56de1818b169ee7631dbe1e890782f34fa70a1327ce0df0f191f6701d022d907499155403051c4f3384d0fa05e1613cffe6f9c0175e121fcd5c2a5bd1ee5c1c14cd3837c4578f61706e80af0e5f392030716e4f870f278511c56cbdc04b96ded41576f44e6fca066f347b5924d7eec0c3c3310d4f01063af274e07fd859b155f6d2f08fccf3e981ef929e0f5b8f7c8b262155677731cf878fe7d343d4f27c22c5d2e506c7842dcc4802ba6e1d0b52f5f8cba24815edf2de0352a4496f0e252c9104c41ff37cc2301f5b1e97300f8fe7e380e061d2f369a1892778e19212f37c2215f88022099ebd3c1f47032aa4f80082e72ea0162faf0916f37c16080ca7e0962e1e140d2b8f81637a078004518e9f1e92e7f930d05e9ab8b47ba6cfdcc849e9d8b966352758ae1fae807679497ba8b9f605b2fe2410cd1f0d8235170d1eed0ec7b4bb45e601390c724863d55cbb2eb54b4d521c3ec649619e8e7b8d181ce6a3dd67580b43c15bb889768fd3285e93d76b5e437ba0f9f505d26afee33f680fd66bbe40f24c83d8e63f686ef3d59c58fff12d5ada5d9b4db4bbcdc4a98e02b2b98cd388efc474ecef464e4a9ff97bd10d58e4b39b7e0316eddb4b974e7342f3eb4e7362bde63564b95e93fd7a0dc5810fe2b8f0f074dc6966120e7450b43b10e7c5c68169f71f13a7725db854bbd2dce6cdd331b2e2baa8c8a80215789191139c1b4a37dd447b902f7d81aef38d9ce0dc60ea41bbe90b5473a641f1f034b72e69be9a13ed5d738466e2f05140d725d42ab040594a37dd205f3a6b4eb49b0e9d642f7d35271b35519cf79930dafcd371cfe6f574dce5dca7539a388fd6b0fc0246c55c934c330a689f4e5d3cda1d694345beda601f97c4b3bf767c20d052c08a3035a8a3e51660bbfaa6a569736ad66b6df548cff38140ebb080914e38830df6a6ae18c22b1a63bc428e8e31c21840e8de1541e8f7bde9e7e860ab7a5357b8d1f5ed2a7e3ca80af0e7038192905565bd665db9aa7a7578bdaaaa2a065b654dc827a4369810061b73d80107108076bafa76c596aeaaaa8a2e8a6d1b1e72143950400145156668a9a2075906d09baa428a2a56000f9789a61b27dc1dbe5ced3d27dba666b0a56bd60c17493c3f2e92152c18cfc7edf2a3d525694c4c5760c3f7ddb7bbbbb36cf0e5eec93d9a8b4f46ee5e4f90c6864f38631a1ea7a249b8ab6f0a8b3e3afe2702619a5f050bfbbc545252920f40fc19b8675333e8a2ee1ccd40756b19b86763a0ba633a0b4c9ac198ae8b874f16adcba6a848eaba7b34bf9a1048c389098133a6981038830b9fb679b8879d1617b8c7003a5d6380401a50bcb9bd34874f930a8b6e5c844f4c0301349ce053dd9a798be361e103589f6d0f50ad607bce897be2dd8dd448cf27f7660e9f503f789145891f7e90022aba9caa18e2aa42892c9012f1748c31be6f04830c2344c14b0baa50070b7c442b18f19f9278ce9fcff67c2cfa7a81a9230a47600187196fb001147f714f013a7ecba32b2e4fe84dc5e770cff602455a89781ad227b1b93f27eb4dcde087aee78938a8b61b1b2a08c1db4ddddaa60944448a84202a6d0e1884f5d9d5a942dcfa6cabe3beffb13efb74f6bb3dcb279c8eaf465249494949403586de1da3f72717d8e702dacb0dda36c5658ea6e94d51918753c1e6beb9df14a99028a7bf38810f04827c5a57af7ed6f0a6614a063c6898949494f403106c48f9f4be6dd9767b3e10c87d69bd9ae766e3c526a4372503321af6a6641046d7ad1d1d3ae447879b028c0cac90628c1478345f9aae5b11420821841042086191d5910ec13f2ba886a55f5d598bc4aa16491517497c8be4f12261b748dcee545f62edba595dbba5455697e850f51893c457c7e63a25b6d2b74b2f5d43f0f02e6a41d80ca876ee694bae3b5aaf6b0e554e835fad3ae6aa2f787896b82e9e4b12c9987853727ae83de393f5eb5c1dbe12e5f475ecf29a570a36ebdb11f63e1f08c4bfae26575c3b0ae9949caee8107ca4dbe598089ef7de7beeef39663e7c7438247ec073bd5e0284066fd480c721110f8972fac13ee25e52a40b27d8d1ee7012e5c076876e8e20b79a8b7f5ad07bd3e23bcd9db5c7ce4541c6d7dddd172f8704cbb22ccbb22c6b935853568c35eb8a593133df1be1e19eec7b171689fcbe08fb0431d5d03840cb0375ebb7ed732dd477fd1d5ff4a6eeb0a211d05b04f8f41e039fde8ff009079b0c4cebd5b285ad6e1b3b00fedde619a18f7e7f7784e947859603411a1db30d6412d7705b4b2671fdb607045ed7b6ada3bc65e912691007bae1179e4d171bfffa62843c7a5376e0d12ef4a6ecc0a28bdcb60f90bb65e9f2e08b30a68fb88bacb6027bbf4678371fa42e13be577fda12f88a562259121b7f3bfef1997908d2cd91211fcdc5271b3ef15b621bba7cae88be713387ad0856ccf4a68af044bb6f4b835c11ec219a129b9bdde1efc4c0b6a9227cd1351bb2d5f4a68a8006b312e4b27c0f5a55848f6b1d7d40c80507b1653704918428b868428e1434818e2328410436c8a8030c11e4b802015420441a46d882881cc84008758841a28f9bde1411bc2082164498a2f9fcf8873a357472aaeacd35ad594da80545fe9b44a78e43d0b8438be643a2d31034eeb8c10584045190990b1e1e2b5c174f1578aa8062c2085ba0f1831254bcb1c61c7bcc7c692c4c0faac8411552e8b16728a1841800e103246630851c7d602de8c1d69b1a33c4982c105608dd21e4276c1b617467e4e42801c29c3c521bc6069edb637bcf2a4212ba6e8ed9a58630071d4cd0230843c8230974b841870f9080841c9883043aa01082173e02a4c3cb0f46a8e94dd181033a6e30c61d76d8b1d51c76c821853a202086055bd8b8a28a305cc431c71e488c61a137250421baea4d09e1872110610843e0e1e111735d3c3939714098c34290e38b23e430430b10e46043080682d69b92230972c8918a630e3179d0d1648f2d7ee083128e98c2173171e491050e3958d0586f4a8e1b58bf9e0f7f6fe4eba9dddf57aee93cb174b12193922f8f511b66fe2816f79967d7986edbd3b16e3ddb025fa2560516280b0b791020177220c7d2c5061b1de70e6f833b8477c7a80d377f14cbfb0dad8162e96243903b8a85e7e9580f72213408c5f243ad03618ae536a5296fca28962e3814285dde86d225c5d2053b96eca563d406d3672816b7e5e95837ddddd18c62a9f274acf3a5a44cb1b8a4a7635d52c7777ca65892b074b121bba358a03c1debd9b16ca7496d3c345fa01dc3af2ee9c717c8aaf90239eb3faf3417c83417e89af5b2fe6362e962837c0dc5e280e44da7993d642f7d9b3d74b121a30e8aa763bdf41ea0c88e3051eabc3c1debd541d1d6b32d19ed014b970a2c507cf5052ad11ee217a83a2f6d01cdcc05d2e6026559f82e0876c891d4727979860a9c1aaa576081aadfe08022d0e65826d463ab0a7e83df38f1693af86ac20a56d5b3de7bcf2282cb9021848fef1c2ccab61638896e4bbb54ffb074c21ca1db02a11b624b745baee016e25141321da1d857ecc65655cc5565552e56904c05678c5bc2f0b1c61c5c8fb812b9d0d51f841784b02275e4c751caf78aae6b019ee7cba3f931c1b5c0afb81233071c615ab2fbb58f274f48e659bd6fe6dc737883253359e9aa8088c1c11061b0b1e193735d336cdad060c35eb3a63644f8061b7cbd7a9c03b41c88ff7eb103f8efdb83a5c76a72f68ce2dcc0d75e01be46518dcd5286fd427569ae98c6dc10af8a10be127313a4d0b6cb8ed5b0243cbf5e90fec6559cb9ef2e12e865fb085ab4667d3900e3e2cfc7fdf960efd8bc9e0ef36033c23d77135ad9b3d806dbcff5eaef3244e010fbbb11bee68d159bfb3e7a3d875dedaca47e87e15f3c708fa3154b5bb4be57a9415d32475957d3864fb1ca11fb6c7cf86611476ff8c45fb67a0e23c67a7538a3fbf54b57595fadb25ce57a2843015ffe3c6319b8e751e79c730efea7cb562502d91bce239dcd8c4f1ba686e7735d5b9808c82069bdae12addb86d17a73f39f4e7cf0f074f811ba33d111263553f8400977541fe11343b7c4eef0b98bcd864f377cfc60bbb9b9b971375ea4abe08023d5cfc4d697583b2e02338b245b24aeddacd690d5037ff8e42e191689af2e7fccaba608f7545a743c0e93ebd56d1e6b5ecd7abd569fb1bebb03af03a9d72b20b8d1f11610c668f9abe6d7dc5ec4f4eaae5a67ad496c227f51a965399a9604d53487dae1c4a9f98f6f976e7320b3567f2f4d1c26f23697b7a13835c761f2e3da7f5cbb76fd3dc87f4c9ad7cc24a8a6a141b63964a2f2337348a3dbd83cc227476b462b38ab678bc48aeb78c73d1575d775b92e72651e5605b37e545dd3086b02a5afff70e93a66c157975829ab0e5fc16c7762d092dd71db480e65c35699bfc359b78698cc1e562184477053f001d2f11833a6abda3484b0e1abcfcc3c3bcc317db519539c897126ee8e7b76cd2d75d482b03bede761f39d28c755b3820f52d69814e9c20945e837e3de1d7078693e6f37bdb36b593f9b9b7e45fa3d5aadc79b6666c4663a76199fe9db57336d326c9b2884262d9ba52de8bae35b4751c607f932b92704795dd7755dd675ebbaae632579ecd6c42c2ba7adb52216310cabcea78aa7ba66d19689d192b32ac15f8fd6ab2fc363b12d9f2285d510373757dc38378f40c2bd0769bb93cd1bb64db5d1455bbda937d2e87af59eaf2d129a2f60ef1b6ef40d9f1c33126f58d1f5a6dde8f78613fd325374ce39cafd3ec676f37cb274710fe2405df8ef7f3edb3be449811b79f4a6dae8a315d09b6ac38c7e8f5e2ed66273afa6eb776b27e493c53d472f56b14125905e4cc616c3740d3638799536c034bc17fe815cd32ff90bfb056b917e054063f235a7f7d46b84a7f7e675ebe5edf96c145e33d0647aef3d9e999394d9b4aac6626b43e4ac4ec4d282b04b4c4aae8e611a1357a6826d3d5965d9e4c666964d97bab26c9b36f3068ced9dc3d8e04b333362bb5eddb22ead7961efe835ff952963317d199635b1ebd057dd9a65a6d59baefe3ef3f7aa8b4f950d9f4a74e3d3ad22774da29baed8b2e81164c23eb082394f329b21df2511ce6293e1f95c9b55edaba7d2e15d13dce34476be9bc271e11ef91969fa9e86868626dbb62ddbb66da3179f689ed1d0cc999b6625ca699acfc86da3f98c9b9999a199b95b2d88e63fecfec3a6ffb04c72d5ade769e6f2496eb416b9d9eee6eece4667a66956c877fb6aa497d6ed19cd9d0bbd5d72963d2d48bb9c99ee34759f99fec3bdcd6dd33ce29ec9964f32a3f3c8f3715a1ef760db6354868bd6cb59b46e5b05a6ba2622adeffa661c6cd535518b3463611d76592efe0669e5599a8b4fd7eeb00fb67d3a9bc39b9344b4c1a5ad5fd2f4febe3fbd905a711d74493964bedfccf71f700261838fb68ec304de3aa4153bcead20227ff04176e7822f7dbbd39a58aff058136dfdb5a1a5b3acd282881c4e217fd374b95a92dd9d265876a9494d897520c72690d7cca1ec35df66cdbefdc78fdb4c1c22dfbef9759a5f1387c8877c7b35253897138749769c67c7a13844681254db1c87c990d37cc8696af8c1016979f522c730ec43a6cd6fa6cd85cc3a73ec41e6d0cbdeb40e84d6ec98cdfc4173f8145f645e4f27be660e61a7d966691ee153bc690ecdd0e55396d1e593d39258c770e0b4529af24fbe44a68449ce4ad3a8f4a3aae518f812f62a739a04506034a4bb46b0571a0dd72df89fe7b422d749ae5b87595f14f229eeeed419aeb25d085f4cc8186711bc53b27f77d46849a9868e372a7243e8f8243b848ef41539309a4845c1a0e1dd0ea121bd5cbf5951d9161bf7a6d898e2929cc13512ffbf59abf76de2fe284e9285fdc370f7b4f0b93f29dc157fed1c1bf735d2fa76b71fbc932d500bda6be61c9bd77cf0642383cdbdf2f03c9f8b75f6f54873dd39e039c03d6e88376d960f35ac40838c13cdd39b4a4309cdc6123fd0d2f19b232fec57adb0dd7befbd57791ad2ea687595c6a4d496a6c43a3ccc03320192e11e18e4ae39830c73e3d36b23bb53c3c633d8eae251578c0ed7b56d3737ffe9c4d375f170f27c6056791a8e398979981b300c7918c286672d083e282a317273b84a5a735abeaa79fd4d5f37c23da6eb39dc43c3d7972fed31d6d0fa8cb20db61ab8a71ec5b679109bc7db5023e4317b4dcde365e09ed2e365906933cfa778b662cbbe5d2f200f422f3e452034e3537cfc99cbb69d65b779cdcc2e24ebec34d9b799dd34b3cfbcb36b5e19adf295dc9458341b53c310886d56d8eb4ae75f25b7dbc50e07a5bbb9cedd956625e2e9d2651857927fb36825ad3c5378bad6d043a50f59bf4ab4f274e9d6df4d7777cfd867f3a139f189ef4eb3cd9ba7c3dfc95c6ca6b93dab577f9f8fe9cc374dd682664ab76eead692d6acd9690cafb831c01b3400c20dd1919a297c9002a22347111e45a6c2310fe17a42602a9835bee40933225912dbfb36bcd31e7c525252bb478f620ba04c9932ad392e2e42911d92e9310d2f731609cdf73f11e01eeb363b2ff4c6f0a7032f026c69f2f94e705e851079ddea55af20afdb9332c3300ccbe650692f0ccbb22177d84587b2ebf13fecea115fb472f37375c7d48de3bd578fd04ae40256df1f7d187daf6e1d2b1416179d8bb08faed58f7828c891facdfa96bcc6feac788beed1b52a7a4db0db58afea8fb85f10ee2077b342325d3938c66c71ec0fdaa5d607405e174ce55947ab20d69de52e64dbdc83dc4a55793ef09bbc4c1a9d7508c568e9d62b27cfc76d19721c5a85984e84d64dfb0dbdb9102a26c88a6918ff685d12ff9ac43f77988783e1dd510c7b95c8ab574866d394bc07b9496b9275bcb3b60fa1558889d6edba46875c8890dfd02def860835c5cf6054bbe662bca4f1171d42e3fb8d10fa6e72ef5a16a16899c52a7befc1cee67b417ef8e5a124beff3c2093e636d3fa3167ee4adf6615f29ecf913f1fb7e5e9c02a047bddb2d72b67915cbd97817b6aaee4a2f991e753e5e9c05f19ad1776a4974c15d25b9e8fe3f274e05ddc52791a7b5d3b1a73d84687e2b363afb0312638182a9e6b4bdd80e9f87e91568e561e4787e2adbbd7cc3a16b325997b3c3629ce75ebd5ab3c1f977a3af0f08e0b142264dbc86c1be4d2107b45e44267af442ef476d32b4f5b279219916dd74e336f76c7fdd294641fdaa8bca535c93abb4b3d9f21abf3e0560787ce36dbb9544322171abb89569eae5eaf869f815d1d32c1c1906197b7be95166441325d9a1b6315638c974521135c0b551cd33b00d48dbb0cd6c8d259574ff51a68f40bbda9359650c30e35be6835f668d96e4b4b539533457a9f4fcdf7d766e3a675291dddba82ee57057fb95fa523b59bf575f5eb72523db7d1a2d743b2fa0f9b86e44b7754a395dddc28fc558fb81e4177d121f9d2a192d715d20addac5bbb88c282e4aada43c357b43a27bac61ff1d03b52c359df92d7d62becf8cbfd724bbcaeae2d3a04a1d6c47db9c7f4eab638f98abdaa68755b3ade7a25e911b7458fb8315a5595ab5e75923307294ee9d7a33ba475893b6ce20eefc4697130c057f44158691e5fdd96be6ecd19adba200dddae0a6e5945ab935729d552c6aa4b735bc2c396131e961e7543382d5d593c6baecdecd58c37cdca82d4099fa2bb5e2f7795e810bcfc65d16ae38670307ca61eb13b7a2de910bc1c0dd52f5addf3e125d21dfe9af5e8e158d71eafc713616ef99246332302a047a884aad4eb83819c242143886666060024a31440303820148c47a3f15054553f14000ca3b648549c08454990c3188a31c818028801c000030031060c29ba290fd8ca06e001e3292f855e1495f1bdfde4eeb8039cbdc712ab3578ee2a76e09b6368ec1975666a3083d2271cafc86d5ad8243b58a0c7e584e1062fed25a095a0422ce992e89c1255508be5d4b815b471db9450cd06b87d88c899142cb2ca233e2a03efdafb534b1fa96462d2c47e18afff711adcb483e106d04ce7d118d122cb1212bb898cc885a621281f444c2e54ef09af472b757219e67622956bcc355cbd223c48138f362e98b565a8f391e2934c95d14e8887641acdc0e007df7738c7565b3f38d67ade50331e6a017089f4a01dffa7495878502bd6ab662b84c234278531fc49740fe8dd2aeccfe0f8c3149747b31bd483822a3d9c7e23417c4b73d1a331c479f2174ee04d71209479a2cdb3b52f9c72d99f8dc2a9993e5c2b3b71c66f53015a14c3c6220f7a7433f7cc2c9cdcbc5aad97f9b03b29e292dd52bc82364325b34e476ca0b536b905a210a180773a59073b7a4f0a11b6235ca76da3016409b96af3a344c77630b15282d0b29229f97c3ea7b2f0fbc79c46521a4ef0a554d218870b81800554e00564c1522428c5e51a34835693026c3d559993e2e38bae396dfc4e32762727ca3b8389a6c2a4ba3be4060a526f0b7de6a7952407c4ecf9f1d474f8e5684122b33eae3aaf5583c0660ba3f8ab9d2bde198ce0ce901e84f8ee5f4313c33d7253885ae73b7f0fd2527c0d427fbff7c0e134df7a06c291360357ddff5d1d2bbdd6864fb2c917655c2ee87cec3277bc958584d7fc96457cdfc45fd8492870d5393897c6d8e3efe9a278beda75d0d2e6a3a16e4c5ea80e89d80317e37bf69476092330357fde0870ce4e0cb9e3b9929ba47ee91c70054edbb8fdb6282045e9f42fdb95b2ab1f7b7cfa18fdfaf1e24f3e9ccbfaa001dc63516bdce4dac8d07cdf4107a975d32359c9bcc31cb868fb4b90c2238b92273f14e65f23c953c61dde274fb8de75486001e78f5ce6b1e61dac791a61fda31009b13efd3777edf4ec29281ce2fd18a173b5df5219e20dd25f905947a7e24040c42254c0587947c8d80111748b91150d37045d10d123233198ad9b381a513b191377383799197ad0910936053d80249041daf0dba96101b1697d68ce9a6ad1c4bbaa10107b2043f79a8faf542155210542a1b4e4c0e088d78fd2fdf6be6e1743ecdf58ee8a5de049f7127599af821d28877141917a306592795f3f49a59596666080ce19b7c4396371ce62ba4629565a2cd25859c6c76a8a6befb1dba039cba564777d08706cdcbb41bb7af6148ae783ee2b516a91f97f7936a1b87504b955fd56e3bdb04c6bcebaa67e3e5a1c71c4261454bbc19c332b9f3c9a7a7e355a4064abdf5d6261bee6356fbf8f399409e68448b031a38f3bdf218ca2d3b942f7a58b8ac7282bdeee2956dc5ca7ec3a1e51fd61ba788bd2e88b2d1edd3858bc78b0fd6b3c4437bd104d9041b9917423c4310ee7412ee596f2b0a89cc38cda833764f67ceef5588c9414da0a415f46aaff7f09b198d31bb4a5722794dc279b91b372c740d61a26042b0479570f867308d97f628b4997cecce557216204781cfac9b3319eed68f45a091993b4d2b2ffe1c294c9ea69a269ac1465b0dd3f4477b4a121acc975f3a02c3a94f3dc2b29829b670182dc0cba8d3fceaaed371670fb305ccc365d02704674ed55c9d0e793d99a2ede7ce51a996cfd7f98aef1b983fb0c4032c6c08ae14974cee823a0077504fcbbfd5b3df0705fc1faa2d604ab48fc337997b9615b2d168f4cc2a956eb4555ea626a2ca0f8a24656e50ef23ab728785970b84cd771c1ff54997e1f17ae8f2d50e34ed2843f05ece44845c5946b31b8c7bbea771abc97c8a5ebde33408d64f2c6257f4559b4bbb94f2a72ec076b582a125176056566aa498c1b243c78a3c877a224c6a9734e785966247e73def976d24562fb45fbb7740823b5b589c41696b2f9dd39dddef202484cf4418460a6ca9a3d7f089136d97f8a89cdfd77b013405908172a84d52771fa04520865d43614854b036172c8640066be4c663cd7d79700f4b50e76ee0fe2114890a4f845786b8a3fd8e9abd5c12489fff6f78303dc85948cd6a37d3eb828fe7fe5838748ee41f5b8bac361e15a2abd91b806eb18fe879f1ef89a989284b213800b473ae13e8c41bf2f6c4e19fbdf5dba61a27756dc3d0f9a50f619097bd3b6a050134e4b12e9ce05824f6b61a701a585b148dcf8a220bef6b142d21d75c7a93e260dabe8d9def2001f39979be6fbcfcf80271e2da136b440d45b0f33900fd6e8c6eee12e19e6d1b19cd054476f6398fc43e4b13fa9171a4a5e63804ad7e7ab1a5f4c190c09c125abe0ef70bf814eddab9f8798fb52cb26b1ca4ae3a11c22035ca5df211cecdaf17fd7af2f5362704d47537504d8d0c88e1d4280331ba9ca9487edb0ccf01a330927023b8894c140e109356bfa897334e645d3361f7632fdcfa641300e12199a2a4ee817380a7d001806458f69af9765a7ba17411e58832a06b8c275402a6d11296802e022d7a69dcb3c358d8e921d629aa36291acbe9052221814696d1aa1cded3bf750cc32b5d13af68a905ca235e90f8af56b2eee69273de2916f892e51a627e0dd699847494f23937c4cd7cd64d316b64cdfe8d1b752d5f0c05004b042ea44761c3c1d3545457d58ca0c560ebd50faf8d456b6f8b2e30450d8712251e31c65241644e3f77e9e516d8d002272a8de8d37898d5ad306325fc2948d776c6148070732eae468d3c12da0f0978b76aef533c13f39d4ce15fe1f3d84c1da7111b55484366edc5eba38b75c263a6a914fd4fffdfd02489d6c2c1eec6f11844e1dc92e257a24423fb36bad46f4375eae3f919d85f1018fa23c7b0c2ca05e7fc05c169b54504b73ff6ec9f01011c335a86199fbe7af862264e63c4f5aaf6965e5041da36d1ea27c6ac6e0f444bd34152a393f184d2dab5dea38096c1addbc4a7261413d2ebd3a6af7de48f3cad5856b1bacd073e3890f332eff5bd5ac42f491dcb6f33b3f2b0faa80302958a15c7cfb5cf0d59cba350702c857d030de3fa169ae600779f1695768253e723720acacca46f6efa0bc86130c84b7a6d2027b8450e654cf65dae115f7cf8c2746f384422952622a41dccf9a906b5185a0d0ca8c350d8bd1d532140861e9969a035b7056f954f2bb0934055c617816715ebef28df1106687f939ad758d03c04ea82984d053b4f98c20d7327ae8710577849fd18357b5944840cf2c45e161df292da862881287d3062e0a3aba0d5480e23d42321cac411599dad2a733c49a477169d35d1e42cb063d8f42bfd21a47381b574b1a565bb14b8acfd356450932ec4b6df913d89927fa13990751c49f73466de9e7748bc816e6cf7d184a7b37c7a7b06d9cb73cc122a7704fb5a65b98a233fa17ae0404a0bfc4dea9e3e0ceb3308269d8f915b53cdf248337bf753bbf8cf88998bd7e75f3c4f8be2c236452b92df53b8a9d1dcb289cb54f6a3903cbb38fac8b584a1abf742e1af5c419b3d2dc265fcdec09014072e86da59fd1e4e4febf57da23632067f7cf7f1fab59a1027f18b131d196c2a3acee09f825a4184b1e5196c4fb2cd1d68a4eb7201ea9ebdd6c4156902a3b4e3f70d7b884779315a8685efac29bed7032230029d94e54207f19216788edc84a929e9f84a1db49d00db66ca86561db8f402501b70f9aabaf93edeb7055bb03ad6ae6cea47d337c7775ea380e89d454c7d44428658230c2e0b5d02a6f8e857f6b38a9ac06fff99535f5a3e9af2bb90702ac80820ec41424be7af2cebc0bd2bcfc4dfceb9c8326403345678cf6c7be7558f0d5dac924b8f1b38d8a5ed383b8fd91a54583a57c5e48f1644240b089ca396bd0a9e799a4760b7f787692dbb825472112aa6ff4ded9d6f4ad234b629c406873b8458ecde64135ab8a61daab198d41ca0968a5a8d606f36dcdbc5071adb30d301343acd6e161b389a960edf4338aa5f276393a307d84a370e1508d4d308ccb18b13567d7046d56b768b5bd06bf7dc180bb83089ed963c252e1173f27e954fc632bf68d7da611ff33835fae3b525731979bf20d37355ef37c0542e22d940ab4a75ebd87d0671338c3a8033f949c5d3daccae5b77cb87ed6b0e44179c8eb2f8324e7482d08690f7bf1a2c589a83a4627a13d7115ddfba7757bcc03a4e0a86511193bcbf914504c04b0cc369b5e7f2a77a9436e9338db256ae63ed7e430ffd1ab09c850fde7ec6615b23db47eecb708ccd3924a3352edfc8e33d2bb7baefd0462f478ead753b2823642c8e697bb02e80b877b6b0a68a70bd39af491ac2dc0a8ba536f740f82e84b1815ba43d83ec2b25f7aa44623f3dcfbbdf745fcbaff3b5854264a71b47ab57488ac581c7b90f68878bda1d4c98615c2e2eaefc0480a05709935dbc0bdbbe68e7ef8ba4b2c7762b6fa6384fab34236cdf2ab18e6cb9afad98674f162de6d88257a6ac9758ca44cd788c60cf7d723bbd1281132a7c0be3d8c2723b5e484e0c7cf45d2f2da9f0bb8c7d57288bf54b56252122082bdf5d582ce0a991ef8fbf593b9a3997464c0d862174d02ac625e610a6c90a7643c1e6366e9ca1cadfcd90f7385dbe114356623aacadbfa01a77a0b0ff097986123625a2c301bc33b418ccc41ed6f91a0620e0fbd3f64f43c3b05043ed8dcfd289f6ee77ad1ca2ca34740c4fa25389f2363ba232ee23106d72ed10c8a4779f528ca82f55606e65682f6e286c3f4615a2f7e880b1fdc38448e22c406ba60cf84a1159de13f3fd67cccaf9b15786fd46e8a3bda3b9f75c38016abaefb986b6e3dce07d03b52c668b54d0080402f5655b328d95a693948d5c5c555c70fb0546279caddd0cd4d073b51a3c0128a7dc730a16c51a2c839f635da1c9785a0f4b55b7619fda43217c1d2c58e83dddfceb6d83df375777473ce5c3b3c9f7f4575a7c0a14b2b57252adccbafa0189fdc763267a84f456fba4583b4f0a2e27a1409d2bbc8e720bced74c8f5ab60670dea5c23c21c2ab55b9121adbd4d2f42708857d4b49ac95e67f042c727d4283d73019d4cee8ea6983e7da091a83840807e3350963f75d4507922aa433dc5d4e75bc19a096bd9228927f80c70c59d043750864538b04e47637f9492fc8b847c6b709727340e6b72315ee70f26b84afc7c9afb2a5dd412b5584af88d787d34f32226e0a32913377f3098a5b86c7b275d42240802264b4908ddb3101222bb084704c0a87ce0711b0abae52b31ca7ede54037ab8481e8c532440afbb832d3c92ab7170e19e42934ac54e5eb76eff878893855f3b596703fdf1057e4f436c2186155fd0cbb88a0c89177d354d3296169e1384bdbd4cd90abbfa8726f0d6ff65f5b923709a5ef0985da8ce74b5a1d1ee1de080551b65aa9dd36219d27396149cc981b18efec9e2069e54b357712f1cb93a6d6c40468a9d7768d4acfa9e351365d051d299e2348d292681527234964d251f3cb300558ff8770c3fd194caccbda7f92c19036311e9f9cda6f97980d5bba9810a2d890ac834436bb30f31c4fd4f8f9cdbe3b87ef34bff742ec219f486f520ddb448b9fcc6d37620dde8633ffa193fa060052628b9134874f77be32b08a4fd52de8571ab050b360922813d9aec4096081065ffb621cca2ecd1361df7be5043101bdd5fe99089a4d537fa3dad5fec68f6a5dd22edc84febc1c0e005d6a4a04c874ae4fce885e4d2f48d8a474ae946301d6c5dab429fd670a447c8e0c76cbc30ab9b95c2081a3286ea703b9f753d27559b134fc62c44a83063a53e3b990d527a3abd4c63d59b15609805ca71ab4466c53029e3220a1c6a98f69675a37e98d284e1218108b93505dd2f634fbd5cf5589ebac036573b327068080448624e4dc401b87112f4a206f9ee15669d590cbbaabcb46f9bb17d683826e7414848fd79534ab6a480547fa44a83eb6ded30812b8c69cf37291b4b88dbc819ba4e6eff3321c74efa90b93c28a447729c0cd963b2aad1284b6f618e50a5082ab03b0817c021c409c94a59425d327e5cb3a300e7d94f76bf15c11cb410e1f81f0164505e36b411b4ed198007b5a7461383a7826528ee9982b17c632553f9681447659bf62086e7d1692d10536ad7b7a9f9a8f920ae07342ca8bd8eb9006a15853cba43cbdbefa34d694717815d09b6207f62d2bfaeee48e05379861d8e4fcd86ab2600395ea209ba567448bcb442fa0ef0d015136b4f9552c9a5eddc48cc31db2555befd9baa03cd60c9d2747bd3bca66b72d9dd2f8967cc99042d20506073cd02be4fa02eb6fd51bb103085bcb179b2f7bdccb05a00806efef4ff375d315f1117cf4eddc0a4497bb80ecac57924c4ccc6ff6c4d7aca048427de889eb32e31ca5163c890b027fc5d2ab3efffb9cfd0dc8bc38145c5c182c98be8015fe0cf105d735461325ed448215c8763c48c92c7ddf65e7dad49a7e8241b9ba22a07b99fb1f1a5ed970e9a1cd626d6687956c9cbc463d3ab845fca14dd243544822b297989c247696324b8597bd09122c06def3a52df7e9232e2bfbfe602220eb19fc3a60c4cfa3af6476312c8a95b34fb1073b5dde8a955d748936d9db3de7af74018c2ee5055f867313221fa02c95985baae68f863dfb0708668a2bebc4a8a08d0a745ec1ee668eb7ca588fc525609ccefe7adbded45c3aa34bba4104a0dbc4860113cc62351f1adb5d044f00d4a226237d9819cb768247dcdde902827244e65197aae2cabfc1e5fae12e7e379864e9df9722a131f1f9e3e935a2d2d506efd831b86467295d1af4be890af466cd88571b085b330977dc490cd8d0812e597482c0ef58d6ef4d2249e9b3ca7dae2284059421029c87a7a3c41f8c3f3cf24a4c3f2bade580b27c4b8e9565d28adc673ae767cb4747f4d1ac9064d906946f600ed35c0c406886d52acc46f8e957b71669f1aada0c581ecf6f1552bb239d19153c812d5b482c685000c28c8713dd12ee6672dd22b68101b91a4ec307753adc3071d059bb3cb4962785059483298b88620bda5a1a054db9e741936ce8c2057517b2b2db8f3ff6b1152092b8fbfc8a77dd405b123bc1b2d4640ca044ad08689ee6637efe931b657dd8360191b4db59b58060c62d86075b673f7c7e96b041b08751e78cdb3c227993390f88255d8cc56bf1f0baa669aed1a5a7b6a6e1b7da69534dcde1e40e6362750cb03a82b03acf7a1bed52a33f98eecc2f5549f0a38dafe5b2aa865277083596467756e54b79f4fc7de299cf41cbae2baca9a9fb99fe07d1386329460bc8ddf92691d0fad49a12594893ee63cc2058966ec75782324dcde470503b63118802e027115c12f608ebca6276755829505e25340183168866e9e11a227902b571b57d25b3b9d6e582d704bcca5e0a81aa084a826d0c9b9ac436d2e13f9c28c01228813d83f99d5fa7e86116ca60b7ac883f7bf4f87d104bd3f2a2975b350e57b4fcc1466b72a63c84e0a8dbd8e44a84c214ed48e405830126cfa49d0a3c706104a0f652e4de0915af201f6919976da553b26f7f1bba501b839b121b314cdeaef1cfb8d7df2f282296986c0ac3e496a20d507550e1ebd9ca1cbdd69d4496be81f1c81fb0b625d41823cf77e52e5a0d2e29d98d5131f866620a12aad19cad4d77b045198d4a4bece7b6d53efe26bd789890c39278aac100939b8ef8739b0f87e55cc96594ecf2ebe536576e9323435412723af932b0d6ac407417c49a698e546435aa34e3c0b5c1c2b79295cdfae02d7abe9be73405b6f5989231c594a8d58bc8c0e91717a55489767b3c259fe80deb1b6c95ae48c5f215b2beba77bf062b85919a387c8582744b74057c4608c6e8a9aafb00d0085a430b93d88c793a2d07e4d0b20b48645b54e6c98051087ec767943135bf85508f73a3a84d8a3bb7a1fa73f07634796cba702f3e9c7906da504d6cf5b1ea9abf808169a18033fb42520ca651c82cd56dda030ae827ecbbc5585dd1ef5b0810dccb57d824de54fc1efd1cef778aa01370ed80e37c32ed8075c74b26afe6ca02e55d97227e761fcf3555afc16d6901a3459c1a622e6d58fad558d2e6c18ba641522f8f622899dad49f362f708af18879dfbf22587951a492bf673484e45799b685c2cf12f946bbec9a100fc28e9c00efdc54ce1971c2736a89b0dd589604c9701798aca9190fcb411c85b6fb1ad40a238dbef0895ab951125f15a575608291ff8e166cf9a31fe3af6019012ad136b7983a40450e21990df48a3048ab899fefb7935ca14a82fd981a9e00afa40ae2233e182b1a454cd4d1061bf6ad0dff961c6332c9c10f101fc3b606d20126ff7c1e69ecff0e284109c12ca8324d7b603563af7296800a905a6f3049ba01117a6e5f601c35025ff7fa4eae0b4b63f383c8241b7404511bd9be7c0fd01beaea4000279d319c0e804a4a03de2cf0333d32ad52143dc822a512ed791c9270b3b21c3c89b95a145246cbfa2dc5babc6217f0620f559f30405ea75c24d4bb4b6797afeb62f662dd7d7b3bbdf993a383fbdaec135877a7e96ac2d1135773f685d6b151c8e37561b8dc3df64b3aa487e7f06d666396ce8dc2f70dae24166eff8e0778ca752a7507dc0e241301de3baf14c52e1d148374f96ee4f8dc98615c6faa50836dde6edab29fb13c1b5598fe3a909864dfd08154841e11bc97d6d58c73fc1ecbbcb61d505ec276908faa8f36820f648ba5a28df86406d74037a513d12af031369e7385135037930db23f052928976242adb0ffd325667524ecae06d70fa05386038c9dcc5174567aad0cf1f21a6759c4cae34a1214b47c398981014f897d90650439ac8b46377c473de992c214280a003a6c8288e6cbdb3dd0f397c8b487aad6464d649b22340f984a1243e39d307279d4cee351a36a057ce94ab3998da535bc321dbdf8bc3f83200ae5be09fdfb8c6379e9112eb2ea4982a1ad2cfe79e0ef8de261dd37c12ebd9b43eb430768d28e45fccf5defc9f0ae2efda63f1fbf06fc5e402c24792c7bdae36ea2d624bf6a0ce705f3fc1fd634c00cf364a7ed94b887e52ba9f6c92b7f4b5d865d014f2805f34b1430d18d42dffca26ab5107d512689ab7db77f09d3c8d9d2b171149306cfa9f600822bdf8f95d7bc556ed6673435afb9bed2b2936ee20343afe34017e2e4e8923a8b2d410fde26ce40191983049efa207614bafbea3d44b9056b214a9af68564fc92f44e5509e21e9b10763e25e0c092743c372b5907912e19e6855d0415cefc7174d4d8ca8adf59b73a09577a7a1a81c5b0a27d26da02f9446ed7be78b709c188e8b478dc70dbdbef3cfea8ac251c70d523fdb59f82b074ffcfb317cba4ec4866aee453fe920be756e78fd042fdb6bfa8ee417657a6442ded0286298dd32043d81b56ba8ec4fb8e1076a90b4375b0d7fc734982c5b24a70861b35e5d4f83670ec65966cd1943a6ad7db435624af26f322b0551fc75e60a0a20c6133ee0e9cd158bd7780ab0c053cc4f2d6b74175eb6e0f9be14e277df85a668f3de686af72b78439b0db5c901039d8d9f9322c99b3680767da1d445e2d2e2f5a87b296be63c8f86b79049e27510f50652a2d6f461ef7b2d628aa18d613d53140a53d3c7ed3d3becb5d0edbe22dcfb6b32bf2e050a896e1e1697f802bf973a5bbf4a85ec4697c518b3221ec101fa5bd61241526bc879d3d6025cf53236610450deefc1506993d13743a71209a2f4507fe634b26735731bc46daca9301a0ecfd216b31221b7d9a528301c9607321be68f90326103b0030e84f459c4169f53c025561a3a860dd2189436191992748d0a8d621f86042622cbfdb0c94cff6d7b7c279a4989ed9517f01260c972bcc67ac2138a0178a4ebaf8c3d338c63d44d8e697b89588a8268caba7a10ac476f2a00b206fbc358ac6b233442256400f838351a470fa0095a11a6a7163a19c92a7e206461cdf3d40113ca7bd72718751fd8624642a5769c8cedcbd74390970342a46a0a3ad121a878d152560458b059c4319ef8a60dbf992e30157af6db28a77423450239bedb836af9d93c7de1f8ad5cdadf9ba7a1f072721fcf630e926210a48fb08cd9d8792a8c6ef22d97194a0637cb65acacf60fb47388911d11ae3550beb7fc7ea36a6d3e020d9c8a21f32f95e16ff182a32355deaf83f04e3fdc0309bb30948e8ec6de1c796bcf1b1e0e725aff0134e9ecf233cabdd0d5a6cc44168ac7c0e980c63979f05b6199025a8689a7d4915902c456726a102a4e885922c375dec023d7e38cacc0ee9ef7fce9ad23685f31e569aa2c4f36a1d0af845c863b8b2653cdd4e6478cec62555e40b1134fa665bd41cdda558bacd039bdd6476bc676af63e398c06216ef57541ff2aeba78c4c53d78a0fe76c3d7d1e462a349f154ccc3240657b19b10761147b0ac58703ef44fe5e304465a16657bd42b0d81b240dae30922f679afa7d6c542db93b556d1ec9c1f7820267c3667757423a1890180e2351f2ec56ab44bd53131b6ca8f09309fd7521f85b4e0a43dac992c3b58210d29cea86b91646a81596420811f6b26d010073de48c24d2e48ec5686fb957e321831c95b072acc8009033e1d7e785dda1f30e942f871dbd1a44a59d3a3fc7b9103a120739215294fb74541946265cbc5dd0b2503a72ad8f474102224117205a88bb33763ebaf5a9f7d86fe89d715992bc7acbc3d551e5e4a8cef037212b8a95393b199b13673e7e541e8d431cdc8d9e32bac46bd19028c7b7426c9945201b837d3807756eb7d64f1eb2b04cf7f19afc732fb48fc4d5cc162891269cf7d8a95144687fbf151f90f233499e5e52eb8850ac961fe5915ba5c8c86384ee4ced3fbd13ff491cfd237371f47580de1b94207b10bd96b84a8b87de1aad4cb8635b43cbde12a32c0f1f88cba1deca5266ffca33931131e7e8b18258d3a099de3b3ee1c7c0b11ab7a77f4f49f110eddbdd0eddc21f0eb352bed7768fe1a2e893b86a4929aa16b3ae1a0c16a397cb4d334b9d270c17e8f5044e8beb2f7963326ef29ff7ff9846968907b19753b9112e5c5455f378fc70ae64a527f7e919097d05d515ef48b3bf6a6cdbe68430760bdc09438a9b91315383d42c01b83c09ebd5e83cd61b04c66ec0314fa0e2b8caacccb3fe480c55268ec51f5cc40ac48ae9c734582ec65b669cc602c389e1989812136320a1fb657461e9aeb1af4f6e698261ef0c5beb0f193204e4cf42c53601835bd6a14be1db626ec83cf60b147b37efd21a8a3a77a7edffdd48c3ee6dd09df95ab2ba7288b83013ebce01f46e03175deef4d82db574e4b115f9e8a0c7623adbea3a5b1baa571377b7c4864c71879837e9cd93769e732bae9702623333d265f088664d28eccf3fb750a036f1efe206af17afd3a6b965a74fc9c1c07fb962f89508198796cc27958c14dcc8efb0b46fef8b511bbe4cb9f634a9976bede0eddeb98d7c604d78d65178976bf6d1fc82b2a1ae50ebadfec02a581dd358c414e9b444585d9d361a19d74e784b9303faa31037b27a6121eb1f9989d4ff0d7f24f834e55499654e2a0e1f3523aa1fcad6b31ecd810bbd0eb17a1e16ebe3621517b71de16f64ecc0f30cff19a4f853599690f2cb57668e4fb6821f044b54eb7d0ef9cfe05e1ab187afe745f910f76386ce75044b352d338a33b98d9b950e5aa08223799a3a5ab0edb7d191400a008d36fbab80facf543cc0c6e03ac20447787a637625ec774c6e0de3020eb85f54b729ba3aad166a1a7f89bb2596757dd1babc8debc4077ee3a1fbf1e38f7d5c71fb458feb011d656755ab37d9c7e06628ab73b5f428aceca820bbb928b9ef39c34abcd762aca0289529d694506bc551f4fde81181f30e23f1d6c29b7e1078816d2e492404c64e05de827138a214fc2ee57229d006a9cc0544a96608d8c91009697e42dc73bc059aa8fecf2d14dc2c73318153d8d7e22d4c840e8fe00581663516143c25ff2d68c18ce4f0085651b0b3288b0a3895ff2b6c6144e8f8282e1064367339c1a9d9cfe2964d44278fe085c06637160a3fd5fd5ba80565448e47b222416731cb0a9d82ff15b5644474fc282e0862d91a00f48e8928bb156923166278c345d6b49c926218a4e7fa0d2fa4f9f44bc585c70c8f1b61db9471c709cdb7a7807bff31467f0f66e44eadc8a5a1c5d95064815f19761b1777c4696646d3a3ab551f8c2f666659a3cc0603657b314c211228dab19451eb859acbc50c5e0bafc5e2c4cf61f3d6ad0a0bbeb71336958e82d442e698f6e0b307632c008e9f03121bbfd753f3bf3d7777948d070c9aea82e7f4c2c01b4a9be1d1c5cef44e29e51965d88e5a33c774829b03dc1dab0e83d91447db40afde97c4a562a0e0c45c1961da390a24a612623f9063d8662c7b0cc92a3948f9ba6316256e3bc06adcbe9e3d07e543bc8711ba8e1c2c59901e017299e3fd26750c58e6a238ce573ba31af1e271844475dc4a13af988466ea8d59c5119aec07443c237ce628488a8c27d6c6366fede90479a2dd90e33013bc1e33bb7a02cf799da98fbcb983765bb6b2e19404792fd26809175de066f3ba792900cc6141ad4149916e5511b2f8ee140866f68c532cdb2012c2b906f87232ce3793d00151d00a45861962267c40e599b41f3392f12faa487d0cc79315cc950ebed3eb7ebc0225d472e4ff54a62b009fe5b954220d5057411ade65ba9e8f98e2c0c083056b5d4cf6661b77ef37a690418a6a875adb39f5f2994054af940739734e58a06328f997f6b2bdc071a22199cbaa837c971c49e16b94f994dc72cdd5e8bdbc6141193a5393f0c0a862065b392c226e20e2ea00205df29ebc231485f097456579871e8f22766e9cb138eddc745d30a31e4548ea46f576d3b6c1339eb372ee6a88f69705baa9aedc9a6ae000e492c507440a408f852b1160d03af1ff8d80d2c1db3373120500d30bef5c4f73657b7e8b99b2cbce748e066c8d0ffdc0f28e4641c2728de9ba98554da479db651e8fb8153eb541ddb598e9b09766450a3d2a1c0e4f20af84b5600d087c9ef10e5c07133b61798b3d9e19a605cd9a5dc9216f8feb8ff8a273b8bfda73dc2099da10ececeace7ff4ccf50183ba733afbeec9c2ad0f15e9968315297217091d23d92e44f29c96f1a180e5f09a15d03d3180f8bf3b5af93baf54b66e5b8e8aa0013328c64c61afaede23f5363d4c7b37e50a029dd4922770b613cf822b76e33e6cb62a75126b6bd8f62b1a7381b329b5d4cc82f602484c27f624f4f39e53994efa6b188029d55990b4a1bf8becd1dfb86ca3816333fcfccde539f4402928560cc8bc3d0aab36d3f163a2a9d92073dfdd3cfdf349379bd46c1c642db0791fbe0f3ccb5be09afd84b74e0dfb4a1d02198eec411e58077a2fde133c3345a20d7806e14cacbdf328f6e25c227c48a033352efec834f5262ceb2adbb115e62752c373f576962b653be66b254df0d40f25967b9fd269bfc56083cec129b054d1643468b25b435d39069bda563018300e4d50a178d719287b54ebe4d76152f60fbb0de150e37326d5a024fa4942e0e8f36e03552f3b44af825e16a1f15a12e52673d1cb3d3d7f4ab5d26f953884ee7d6eeab62b1a32652df9e0a0371fb4e409e2cede452020aaa3deb1ea2580f67f6d4e8cf9abc11b8a5202e9a55574586125d4f5165068a9b8e4f9af93508c786c2b024944886e0f9f114b759e62f4b702e966cbc682171ac67a1937a210e3d2dc3c3e98a8ec1abef9c508c848369af712c21909044d6c8614eaadd44ee129770612dee036c665ba1a5efbf254633d62a46455646c43d657067ec42df6b3e601a7216b0336ad1dfe4d1c52b1176d3f04adc31f2db8fc6eebaaf76b26a3446c8c0905296bc7944d50dc2db7aa00c405abc08f611e0e06c37860639bc006f3bfef1f842a1b1ebb2426eabcd9c1950c059882c7befd537bb58076a08fe3a9baedfd9f4c03af0fd900213827e015332346ef75a03c567ee3cccbf7469098b7384100243188f7d8622be4cd125be07fb9e2e14f3519bc8e41c10b308dd89d43e043541b608144d250a3e12dd0d1baa98037bf469d8ff28b6be0826d52799c00f12caf88eec7e073128a5d2bf957f6244d3109c83e0ea3d5cc26bc84775a3fb57a553e7762cabbe7446e6ef7010d68d7d43578984fb020014531dcb528274d5fc5d633d3af815a7c130c128dbba2e8e9f826d360d6b915c72c0e522e24c9e38283c85a197a39fe04df5f91445ee4427d8a4af00ba1625da0ccb283e7fe05f78d166e5afb943537cc2a986ddfac97ca58b07f8dc89978daebe40956f6a113082591426a596d8ac4b2d86b80f9f09b1ffbbc5cb0e040cfe30c8fc83077d459feb8a8690619ed7a9d8cf0c0e7d9c30d300806702ae27c0d792cc2c7606e558a048f7134b8268d25c0b1659b9af22b6c494a56466dfb5b736c21129eed3de9ece9236bfeb1923b1613b75cebba7d401d50662a1a905bd7cc8bcbc7b8354c8c10d13a421798ab5e9f8c0b3834d6ad51812eca9eb9bfa07fc67549e2ea201e57ce45a966d50ef4ea85bf708e1921dbe0c817aacdff5f23eaff1913e070196f137d1c6b50600b8d9c7e34fbe52c6f3b42443b4a06eb640301c81176add6618e6cc5c460edc2be9ec91879a0deb907bcbe332293047301e8ad5dac098d7bb2afafaca24618ec43015613f2a820a070078569e402ed8a1d14f3f4bb1824db15553e9f7cf35452c5b71ccb657c922fe799423695263fa8d259a060ebd00f7c4fec8f1252827c3a25a21d653d3368435507a21641e1d89dbb40624f834dc38eefcb9d4a6956d1258eb57bf53b7cc3c189dac78820fb1a8c3efa3897f05b848437ac12b4290663d489d81bcd96234e05818c15ed9496ea3859f247b4938dd61812978ea25383138107d16270cc442861987714441af2b8100f78c4b3b5b6626469c9de5c7354e2b77f1ee28b8c96cc99e7bc1bf0023d6c6a6c95068d1fb495c8c4a2ad99ebfe855a81b606edf4ebd9281c82fdbdbf42dfcc4dc9f5eae2ea711f50e329b862dd9c7d7717a42cf3fbabe80c7b895afd4a28e0f8cf45f4f57ebe7f1668aa1b1f082bc46e8a74fbb1bdc404e9472d8dd5480ffd3a09a91eddfeef68841ea8a2e59beeb5c35d47f6d523d284e9dcedea27b38f8fc366e1901c53a58f858ba64eba12dcdc4a9e8e8e863e771a61d3ad7a520548d9cc03edb6233d1ecfad77f33fc3c78913d2eb93743a22d5280a8659c14ea021aadc86386a9f123d3c876b2b70cbd6c378c83a38b18fc8cd322a15f23e3e141a4034889d6fa4e9558afc0de4f1c1e337058ca5396995aec22acebddacc936b48a531d9dfd3cb3f2ab67dfea858e2931598dae856606f6d8442d168e3558c592775cbac585b09d4f18da933ede94c168dc54d8307fc5e494d64e208e3dff9b623c3bb6566c51dc5e0f977df2c67b253ac859dda99237aa721784636e2de009176e8f127ab00be05502166418c82daf9ec680ca2c1e3271c632ec1f541829cb41f89f4c7a880e339a8967e57002cd5b412bf4c7097d293d91a18e6886e3ddeed2bfbbc3419ee025890714b3340d4cc729add6998b592c954c9cd88340aa1faf58cace5e27ff730fb82600ef3b29e7fd95de10c736d6d410a581f5f6b3bb6caf19af41458df008eea0751403849d39e3948181bc625d4461cf72a00315d829dd36af0d0623a5e5ce1aac09d8a61b26619fb5be8dfe2b183f452bc7655b8c860e51f4395107f5f36c7edecc27d3e7af4e71b55b1691db4c6d9301e3d6b569c04f92ebb392ef1705f08bd4bd92ec463f12f2c913350d7c9519fdc93521cd2fdd189f2b14a8589fedb35cb717528dfa1b002c7f6b3c88245ea2e3538831249bc9636a05f27ec9d9f3946ab839b80d9f1ea43ae273a9e1fe7961dd531a08cde4b998066266885ab808ff7bb82547b00aa3ccfeb72817956f58e9507c457f0ba3a6b4a93995d3a0d87775fcdd1090076703c338de6a121594a54febc1b6a40270cea9a05bdbcbf7b660e5e0acc9b9c0418332b561cd15805b15239c46f8bec327fae8a83532476a3235c47ee4dfed53946e8f8e1a82cc99c960edd9534003d3191b48814a7a7db02173f8072735c47b3ae29c8c4028c8575aceb872702b20af6e3c340861c6acbf48191b811c7289c18fb3cb4aa350cea34611e246e56323bd1e516469a98b6b31742221716d993ae00c242a28b855989e6793994001aac79626df18df25a107d504d58de617f2c55299207a1d2dbab8794322f2612d7820946d6fd41c9d3d1bae9e30f5db82e1e4bba87aae5d8050addbd7ea195efec70a11272711c02c9c342cd70c9d5eb1737facb01d846ce47bf2f10407c10a3eb545d61271308e663d697970f546ddb9857ab461fabc66548fd91b12aa97f81f1b89d5d36be20f30bbf62c9cd6e8ad1fc2fd8c41405bea3a9a41afab04afb1711e2c9a969832056296db4f09bfe85da2054d2134a2084009e7cd62cce95e75f894575ae5dee6119b3a4704e80eb82e983042839fa54a725bc1be297b6357aa1af7bf6fee3422fed094b9f221b1939765447491e6d1f93801b89b84501e90f1da54d76fc5c6011a15fd5ea0b7a4c7e535570fd9771fd94d713cf29d1064b73378596ed85239ab9646da66b579f687b2046c7cbb20b24211535700b71308762908868b53595070bfa4e08078ddfd1e943bb6283dcd548765e00a293c8e7e5a94d2f050db474cfc09204ff73de1125f8d017fbd017b8930287019bdfa8b47650a234c3a3d1bb88d681633a1f4d34cb7e150a009ecbb02f43713ddc985b7bf2973ff8dd74cdd689af57edb7f602e789fa926cc9e40edce102bbbd7a864821bde5a17706a7e981d7fc8f6bd8ffa3dd09a7df2cf23520bbe690598881241bea759289383d6ae1b420fea0911783d26d409478384c6a80ea30680f1a564c00b3e44ab6783417827608c4a0f501a838ca11f7480261838b8e3318463538acbd21186c718de76df44da1b2ff12f0990fcc918521b92a17656642f6eef67a9a18e6c8a065f2037038ec0bda5a02f124782e61b1d0ed0b57e517b341ba936f2ca52f7d1d500e4aa41131c7effe90f66fb285c5e063f396e1b18cd86762085916c771e94c781ac63c276aeefdadd8dce72e0724dd52ed163214feb59f307dd63313e2ab75fd22f64444902b67c6f73031cc4faed4c45e5afd04551d1a1e47d179059ca7878631b55c9c57edb288cc2e80e2e95f6378f034831e490ee960869e7a0c63f44b2d1fd7841169a63e9d723c9d658eb41ccc25415a16aac335dddcc3acdaddcb34a90ef2c1cdab47a51a0b406300126b240f06a5dd8c84c7afb34fd01fa9f0a791cc406bc3ed7bf4d4280fc1db1311e58452b196aea9df4f57d64226b13272bd7dd1cae18648a3657df1ec14dd2addb26da6d32157db62171e73e90de3b826ba75de14426997af9a30a26e33f3f9c92dc10329c487f9e9cbf7c283e1295d2734602c09fef0e33ab8e280fc00eb25587af88bf9c745e9e27f1b10787728b8e7ba1ca0d03b3900341a93a28bf151c339a00d001331410b0023aa7fe05d731de186d1dc8bff17bb3330c8b0f99892e7b711e7fed49bbfae8aeb96d70a975abfa838769bc7f97745b1855ea12ac64030bb2e52be1c936fc5dc80bc65e46b66a9ae1225b3fcee6b48905a79f5fb25fc1f47bf14c971875611da4f148a7722803dda90b24c1e8d4816c7a057f06f52980c0410ade621830ed69dd1a29cc74d2aad215ea8049aa56c86d86eed5982bc40d44c0e602062ad2ad568e2817d3a98df1eb891af427479bba89eefc6bb3127a489fa4b0ffcaa4ba12a75c5f96304f6dc8f8edd259203592119466254b28cdd74db201d40c74c7303df1fd2c7a05e877652474effe69fe2f9275c683224dad18f0f659c1dc401971a24d03a03cec4d387af4eb9403c91e311c5177349151d4b6ffb920cff5c94088e0a35827efef407ef45b321dc07d6439df3e4c26e8b405c746a4dfff965dcad69ba6e144206c165190c10f895d4382ec30b62590f90166d99430aa9a58f209f1cd98467232dbf30b40539044749405591113ee6e92a1988a4a60c73661a3896435f6e08c06d3a7b264190c1cf69c14cf9f91e4a946ac221d01ff07e5ac7b3fa0829a442cd45a003143e9960f2db5f6321f8aed227ece11d98dea4907ee24032385d8ec794c3438100de952819edc81f62e5a8990be4ed8bee1b3c6a300b732793920e248bdd0a9d2d24db639f2c4adc0c0cf090c97e4ae2bc6a44e092f28c5f7b55adf9127e9439377775fa6f3e2f996ac9bc2dfe3f270e394a79e54879601c8af2f99980beeb34062112cade39a6226d87aa20f0da16e19d2b144d5b41e1a58712b8ea7062035f1faaafc9dca913beafc68d914610a884bbbedd76e684b9437c716fcccd7fd8c34934314bd298a3888afbac05e3016c43d0e05a23029aa82316acbb8fb1f2bf4768fe28dd2cdf5264f12ccd2cafd2647dbe34f220221ce27c9ffdfa67fc1bc92b6ef3306404709722373d823687f635728424e8be741a05a9a06a91b7c196b101b70934968d3f3b8ac513a392bc26564e37513183219547ea9cbd9386a43696e63ad58c9b6e231c3f2fd3ea177723cbc7b8bff6796f64baddc22fa96f4236b31d80b2e61347870482db0496acf6d05b8440530e837c417fcd8d0d988a2eed5afc7bb9448d018a5f6fb0fcbafe82037e9bb010199c6dc5c107fec987ec8d1e981e58d5c96fb3cd02ca86d74bebb2b6e9387c40366c0e77b5849d627b7afe553eaf03955711d54b232d23444b4398913151dbddf96b9e96d0ae554150a85d1df2ad90f911582c8799abc24778310cab5c25045a7b6a2d3f96bdfaba4b8644986b3e19473ff9537da30a1b7465cb1140d666bad99d66c3115639450cedf2b049b412548339edadaa2851f6115c67d4fd093e54addd2d63e2ab78952f24c9de7290324ee4ebf29b9a46fe1b36f723df80ea9210d395188492cba6f9f4a22d32f9fab688f75fcdd98a87576fe7c0e48aa7501b4b6fea8c5b7801deee6d0a9aab410815f1c32b84968551ec1614a5260a18c6bbb679737828cac64c09fa6dfba16d990296ad291c29454d5d428d8729fd4b25c3d223e3b0bc0abd55645e71b216168fde1667fc92f057acf0f28486d237e7e07d99d8c6649512361ab02a11651bc434e517c59031b1116a40ac4686631c0c00bbe6844da794383e47a9c833355f2ed8c25fb9fa8047e43957e6068ae4a443d5c6d07c20b2ad5d1746f9802b3640c9cac2b59c66df3fa01905493bee21d446bb8bf2cdaace507073054aec902e2ee2bd458b918c7b23437f00da1b3e67b8cc604d820497b5c813e61e068bc7bd4bfc7c8496024338adbda591bd6f13b7800d7af891eed5278a996a1ee732e29b0cf795a36d829b75e46395671883e12254c7ac14ad8943bd605d348f4ce002342dce345c283fd4188b866688f2d8a92b62043575365b2570b0619f8349f27e97198b7c1a55808629c05efaaf40253738d79dfe85771e3a4c2c27181b9df645861c591a9fa828a2276e1994144e0a314fd2bf07824827b27f301c4732013d35bd36dadee8fc132dcb397d4b630aa673ece33e4016e1be6caeeaa3cd0c5e077072a37fb00b794b53daa06c8a1ea3d9f500c3a05a4d5f98763e287c4b4b90cf43caaefd0b05bfaa281af3a955de8ee742ac216ad348a208bb22cc112ee2fab539843f58e38d64b83c0af0b8c438e10ff1af578fa8fe590a0192b9b4acf696371f4da4dc6e03362fd197d94c0ad5061bf29026d6126b09b4c07bfdfec16d14e43cfae37477894dadd95df02fe90d73f96d95cd5b38feebe3700ccbbe6a034235c98a2f417c9c3aabf28f3e955819104881f6d9abe0df60ff678967ce01887937b6822bf60b7ab917d74378acb29c6e41162b75a100fdbc1ea27ec4dc8e31a3dd0c8c2fda055f76c32fd3a9196f0c674efb1612529719b50965ed79706a18a2ceddc46505f170182211d81e74dcdb4a4bb058aa72cbc660607cc8c0017d5bf08fa766cfb643809554f4d3d2a86b341bbc9d9d0ac4a0139a0e58372855034be0b1dc4ae15ab036d18e9e60ba74d3e6ecbfe452b90a20538eb96c8d4eb1588d49ee374639455d7f0c1416cbbb05c3e868a61af2b27dea05da76de6569d1b27b22f9cc662c4daf10851100618592fa87e348adec4d10e3ddb8a69f41098d9e531f782653dfbbc476707c372ac217e60a7890e97cd2e5e51a1a1f21a0218c7728bc6f2b8178b6c2a78d0147b02251a7cac35fb25eebca1ce5d1c10cb2576f93e71e360d43b75469b8f55c0e2cf2a3265b07e9d67c0858f4f257f44c4f6eeaeff839a7d649c104adda23de9ca718ba6bd98c614ff9015724be81ae6658777401094d6050b321678173d52c192f1f2121beb80ff8e2c29fe99672457df8374524f3db51addf95a05e144020a327ec11e48bfa04194d203200cf51fd423d605ff901605fb3992ad73c1a3f690f0e06f0ff0dcc9dafb1796dde057d54ef0223646073763a77be0202d24edebe30e6205fb4ccf3d9fed5fd510855d565e3e482734f23284c1880b3db338d8e0dd06a51f1efa35d62940a585dde55b075137e4f3e4cb8a6dfc200bf235736c97c4b7548cf7d206dffa9b68c1ea47e886bb9a91d6e2d930c537c01a6eb3c3a0e796ca0f360cd89e640540bceb845922fa03978164d4171a521f552249498eb8cdb3ae578d146eeedf614b08616c822f85a722246d512d560ac9f9ba8fc4d8e1514f566a628114ba6454a068edac0baddadf5f2203842b2bdaceacd04ff8e092b1bce5cb25f5b84492c15e72b3cc75bd31a2866100460bd646aff1c5b55373937d304b2cac250d43a0436d905c409cb8242a178bdcd3ee5c3b6a320d109628e624f76cc349770185c70c3242001d602e0ef266f17617cdd01d05028a375700a21858cf540705c977d4054917c403c1a49ac02278c1ec3e1518e980e040128072934c44eb0a8628eb5da91617c83948e06ea2fc0e7ba3c7cd05d17e9f8fca67e85d329b004081c898215bad9a4d0a9badfe7ecd11d7922c62f50e439a5781791e1ed15872933d4e20ba7103dc29cc77161bf410c94903c466d066fbb6ff055c1e3691900b8d984c8f58f9af094760c414150240ed8f5d429d5946202ae289743b5d6d357644982fde955d4ec364f09ded8ede6dd7aba1468d899254355990488c9e7ebaba75a27602eee409ca03eb6e7d30380617036ed23e3a51c2e5324ff3ed87bb8df890838c2e6b1948dda631092c445c570a5b6ceeef465f2b2f939383b6682b5fa94499b58ba0ab38fef939a3de4d8b82ca4818aa58060cb130209e3275be2c5aa9732a4fa9e0f3c59e8559d5a404a4f8aba6142a58be145b30e2f2fe7c6a2b0c86fb82e55ec423357a7b66ca7b21cd4611ce52fb0460ed5d0a41404ff751150fe6c0d4eb9454b3844c2ef0fb28b19b371be9181c498718e24ab14cab548f0f9a5d80eeb2b17f45eadd073acefc2542f91b12fd258bf987dc2584033a9ca1789dceb87e18a6f4cb722ddad604790d71eb56177f715b4560b4d45164d121250661c1aff82b59420e9817268f9dbccd14565514a5eb53c03192ad427059a9c399619940a50ba4aa722d6ab6901391104cfd7bbb12629f45ab17d7a07ead774830be3c306ad86742cb8344cc4455a79d0e709bb9ba30ec8169132405f22f65f49f4cd283154223f5f8197c8e39835d2d062bdddeba10f81e7a9dc2231033a8866a25e67f752c96cee8bc04ce168410fdb175a7cbd8bd76b18d9456eb5abe7403f170700f31278c1061b54fb90a45ad22b32b00a960265238946de221e002e86f8421d4e671690a407655938d90a8b069596c82edd535e787f011929568542796a68494cb39c843da824f01083e4bda76018e2dd12241c533414542874e8c3b809aed7d3957b3a85288066f854279bc92eae212f0db224451836794927c8c0d5df12558ff027b684bac12010e328eca7ff84db197bc1883e011cf6c2c7ec4bbd665fb6b600474cf56d946c83a16040bd5add8c8bf38a08765a59a231a2e2a919a9b471a0a2feb9d721a17b809081dc216173237e2e182fca797fde1161c77e41a083a759894b22c22baf14c48c5e14717299273cc102790220f84f9986177001cac895c06259aa08010875a021eadf9b6814a15112ff322d1392f0fe467512f5d007863a11f255e2e41e2c6e71ee6278050e57884415d3065adb47bc967ee69255977df85cf2462dbee9e05280c1c1271e7eb65a2dd98b66ae45463238c9d36156019deca9b555ecd37fbd7f4a1ead6c92f89f660da69c6b6be36401521f7824a8c24dd53d791184fdaa94122040e76f4ced8176b855311db6ee0bce38bf9839e85be7c516833dd65896b9c690a67208926d6f696daa873e260efd88912bcf20409d94969ad6bc2b04d048f9aa22f8f00ad0562132d701be36b0cd524b575cfee291a4f0a2d338e45c54454d3ccfee2490b65756e0dca9d660c2b49a0a7e2cfd016d59bc3ace5d02c28f7080070201a1955ab893d5b36c373531d5a70012aada28442bf6c8f2c565198268d17ccbfded444f5ed359148360e2b60f191de1c9ba4ce992ee66f7ce44d72399afec2a9c265309ebb6f6667b0629b5f266f3edcd7fa1b68739486bdbae9fc129e0cac5aca7321a59eede76ed8d661156c30e5f37f7dd41be0acd214ab7ffec0c3f43be635019c9c6d50f985aa6b9af3e80e8e7d66309853c1eabe8009e20eb35b5f79dd019e2831496ac80e298b6acc265160aa49acf99f798dd1c93c7cc244ae12f9b39ca5086319992007fd19b6847d839cf46fa3088481adaf797d6ae67261597deda8956527894ead4fa45c0334f4fa8b191ee4b11039232bd6db5a78304bd0d4511c81bc6cc4922753e330e0bbebf06b857d7aaae14a8f3bbbf730629b053a546f460492b128c7fdf38733ee5c0a7cc404438e678c4f094b185c7e1a1e6fd8a6714539a1ff9c9876a584e7ff03d01b7d183379076e6360498129c774e6cab48ce7cadd48e5fcc0de99c9593789e7053f11c5ee847d3ba7f8084921a5b843469ab6b3288e120ec118dff77a5ceca57818998ff17233f45f14b14cdc37f14121882a246f05983102e39362fb6eea73ddf32bdb516638d15e08526996d95f1c85e5ae58cbe4f762cc100e554c6e5e45a9c6ed05754b98d61faa6ee937ba6ad55ecfaedb4dac44c45e0597d2380d3cd8dccd17118225effd5a0b8234217b9574c1438879a1cf7ea0c249dd5324297773d1ad7db67b06b88da3214291c1b7568b3c4d38da7fff8e502ba52088546cb60c1d3ae5d13e851851074e3d78668c132cc1c5426d39010c0509023f919a219ffa49de5d746a4c722445413abfa60f261dc0602c51ce286144b102aa921509e54e309b24e6ee3dccf83d2b891e5f0b6836a770532591d5af66687a4ed9c39169499b96af5141ff4e61077d5534f442286b5ae00c7648d5af4b1805c8f22e881ea9bb81d7b00e387b68a1d092aca66cb8492c46205805ccf36b69f70c9fa8709e6741430ec97084fd68788fb575dd2157a81aaa2bfe7a687c21c86807e8fe91d62d9bd833c46aec03d096e0ef4971379a742577afd171fcfc7d6172b2c7a508e43dce2bf34bbb8dc6d180f59839220566ef07b12c694151f845e8aa1a0135b0272c658ae39fc93ba22fe1ccccb4b34cb6e5ddbe934ce07fb8c7b4f236e3bae834cbc9a6b6b814108b32a2472f41bffb4efaaf544bd2e546ee5dfb0a79dc62296561fa51c36c4c55c437f2067ebb86fe2d3cd607aa5889c9624b6a140c93f819c68288ae63fc5387e9dbf8bf2a081a43c1b1d294ea0024813098a0648ebb669890168679e658f386a6068b43227c3fa0098b0c7eaf8f02e30e3bfe66dd5761d75c2292e3ca224fba66068535a993b91ea2a19b5ea9fe395435fd2b3ca0485d14beb37d54664c1233189a23eaa51745fdc284b135ae9d6cd914f306ae9836f8af569872974e9e15ffb8bf1426ca06cb12c5f629a427a3aa861a3dfc9651c0565e36e51e196575b78f944d2895d0b2e1e38f3f912056117e467ae64c389d091b8b034f7c13fe2ad50d33ba0b4e8d2b7753c922376db457a127712741200b0da928cbc1b624b32e81c29d717dfce55c69d915b23fa58152678b905d3412a8e648957c7195e7511d42ba8ddf8287355365d48edb6d57c79dbd5250dfffb2d9a479203c032f1f257ec22122531c8ea1f854cdd1a32dd49882dd4e4048b1ca9974e4f7735ec1e6be14b58374ae294b062336a9a79bda0a3487a52d1c750103a0beaf7fc00d264be424c5b0b18d1b881aaed20ec828fedd06b72d4cacf6b9d6992c2238938f0af28b1b28b24d010471db022fe7eeeebbecc0cb6b4a07099a59b99167a2614ea011b6047e6890fc3b329cf898307c8a62763d2a953d6ea61b9b1cf6bc752068dcbf26c132b814e72c627f788c11567fc6ac3e718ce1a192e201d729f3792b20d903e2e222768130b51a58a748f17266e803407509aa5b0e0531cb53dad0848cae82c3e9d81cfe6de83b7c0b3278a8b9417e55220ad33fa8a7dadff494b67c5c3793a9c8b36003d0b23a14ea6fffc7f0a817631938fc674c2368ffdd45fb7d34a6c8e815b0f411b2275f25061e2bddc90fbcd35d2aca3cb2aedcbf2ec4d7b97abc70e0d3e6939df4a19bbc1e9c2e79c452e94af2e9da9fa62f4b2fa7a09d5c59522e4736ebaafbffb76a1fee6aeb74549f40b114a40c83445d43b6e94e159aa44bf24e5e49803d27e20c9a618108d8321c40cea7e703c936a35956d5f483ee2faa07603d4c815a0b09b96efb28cbbbfa3d1c84276a2f2df76140d0c43bb205633426a5c66695f164c7d1835dca77a7d9a07b80daf65465c10af60a47e0d2f52f872e37977f2cdbceb57b74148460c297e639c8d211e43c1a5d050e2d9b7c0932392eb864a305f18d60ef60e8c5c3f3a38c6ef7417ceea2a5be468d76727bb859b5c81271ce7b90bd2f494106ba7167c5ffa59e3f9722f0196711356468a0902b031f554f027fe8bc5372aa4f90c79858b83f8210b8d817034f8388c88ae0f601e4391883ef05d9d17320deadfea2d8fc5d7dd1099cdfbe1e64236ec314bca40bb1b884965a84ccca8ab21d43714734c0132bef41a1e539e877f37808253b9355a880325133bb166d1396021deedd152bdc354596039fd3ce9e8419e731600fcde0b7ab9afa78ac8d4dcb8e2ccc7f032d4f792cdead827595204f8a3babb9b254d3c95d71f28cba91f2fe143cbbcb855c12b4d9445592ac865d2281c6d82000f3013de30551c295898839df698db62da99212dc5346e2f43d6a965a29e282003e773cd25541efc266827d0ecdc905c6dc802bef0ade65aa07d2247717d9a5a1a617f43e5b7f9fd66bb85476e8c5edd3dd624661635710ea0a8514858db826d6b221c0c2ba441dd10067d7ffa70a152e729170b7475efc13251e82306340ad8a690082f788740dc0b5c04c7200c174665ff79d74823fd1304bf05c28bdb1fa6d2ac709720ee43cbdceae48edccd0a40eaf9f2d87845e553480c07ce6552cf447430f1aa575a7a18eaf22f5abf1768418890a2c4e5183506d9ee83ea7d2fa582fecb04a42748de48e4a6ef6198ae39ad20629b71e4408a5756486fcc2d13758a551bd2e4ce50f084791d80c6681060a2abb3e312b5bc063e25b41f2b5d4b9d0dd5dec45c401c8a7dc37a551adb2a3359c6692028eb0825f1a2a323820c7ee843efc0563f41e0e027b9d75550650823065fdb03bc63a5650aa468077b39dd95ad21de6f95d32f1d616d03dea565356386677652eb0724c4c523d6c926ae3a6878fa965efac3ba7e13096962864ef4fabe29b910a7312c48b4b3ecbdc0a2abba0c43d13486ff9b3f85e27719a9a7b6768b210615f021bdd8ccb3709b75ed6cd5a331061bb7f8296400ba0ea6ba935c09a70ff5afbe96a40d1fbf6feef27e7a5ecefefafe6c74fb71adfae6fb5f1d980cae239343c1cbe86cea672dda6876bb81138e722a3de43da019399b73a33272901b52a31cb7c5ac4549724ef0beb283de0f29bc0f33f162f0eb9b18d7cebaca847be07799cc51ecbc05757b841f8bc920dd85be90aa551ba8b5fff8d446ec6b41e79f00e5c5f6c6cd36118cb9345c508c8450f05af23f8eecf033e8c7cdbaa9e67371d405fea0e3b8f76e9f077c76b41c6b413e38a15b59474143ef693e33f91463a1397468516dda3d2b12a0a479ea06cedc3f5dd1cb204d28cd3a7d05bab6628460765778cc5fb222b20696897d08232bab1374f5d53571f83999ea80ad5a7003c6224c83b90674812869660b7039afe3dd3e153751849a8dea4da5a56c4c638d78e95897cdb1abb5e50d831d016d8cfda6e608217430e157a0fc01bb4ce88efef2cda83b619d90b2c23922489810dc41c069428e88baf5e0388e7e55be9cc5b71ac9a81ea88c1d37578184fb4ed3fc0f14998d1fdfeccbdef6c7f3ab5608360f9ebafa2b6ba327fafcd52d58bef0e1da28cfbec3e887af9e15bec9829687026cc63a53a20445540fbd25e7221063d500f90201462d45626da47d6c0e8fb2dc6602a9bd699e02af02436b76fa73503a241517af35944e3caf7138ccb555310f463ee58b3fc3840fc350c50599b2e192c05792b018f24f68a8ef41b0b1fceee01b14eca27048695958e0c5dcb2e9611850dfb9c2c1346505ab0c5f8226affd548abdc623f103a1ead856e8cf7ce8aaa1f7e6405ae17d480dac73b9efceb6a0a6fab228e5f870198c45cb2f43719d16bd880321ffee02e332788e9c0aee00de871c90f0540ec14b9b25c1fd03a4c9013a883d53593010ad930ed4111da872edb99e63d143e47a3de3ad50f0a0adbe509cb6e77216e0beb6d0e7e98793172ba0126d3c6c7e4121384085e90e6aeb104d0c6e67fbc0b88ee236a83a99560445de43b6320a22c2b67bef2d654a520633057f05ac046537ec97153b61c5c69eeecdbd568cc88a2101d92bb1ec441a69b76069f1b255ec0cd7fea42a3372296540ef575eca7cc6385ebebccd4f2a2f583ee31d280bc5c8ed9644146f38385649ad3816abfd037d13e4ec4b122d6636a8e80b1e68515543dc0104356cc3b6dc885d0710d8b00db6611b3c71fe365b77471c88f9baa9a39b3ad486c3a9093de0e0d01ade9a27d7b288da83f8de90d414c0dc6cb1bd495f104cb85987f37de3f2a322ef9bee68202925a196f80e72a9e87967e2d0ef0d7069a2d9dd7ab914bbf32067e3ec5823226a93ab06970d11b59b07a4c0da72638de0e01053def094e80b1aa4c9f4028b52fad24a1d4f4c9314aa193f33503e925c9870ea16509102b32254e2880b698a52d334bbc29b3fea0549490101f06498a99252a6d9c1831a9d41538e29a90c740859a799302598a39c446cbc1cfd018137bb605952c680a1dcc05b2a2b27c0f3416988a1ab849a4694a0099b5760ca0ebc165b56841ca9a0486160ca27258a2ce501c224296b00c083527a60001e9012e5af9c5810a0276e58d0a6788f1926cc2cd5183b22c3915879e45400de908d006f6e01233202bd48f1b3828849112026b89ce0393de12a9b4acca333ae4a11c79724a033502d6881198941a170aaa1642ac74a07e8f0949423f07ae52ce3a50cc00278533963664ccacb8341827661008f624d2d17d42b0dd9a4a25faacab4f2039e08bc79654c50698101f070bc59a505a015259712013c266596b287a7a57c000ecf4939c590292def0cb53a9b649014955aa594f246d248abd0e02056521b24f0e69426e0d432b9d45082444f5b688dac28f3c80b5f654aa752023ca132e42d29796597b8c342d91df0a24a2856ca1a2f8b4a69c34333524eabf935bf50e19949869465a5870af0288fe92a0d898c27579cf0a045574e3aca107854e5133d426720c05939b9b6ca0fbc22650a1f0bb2f24b6c06de938992a8ec81c3300cf104433c432c86611886a10c9eb23cf92031a5e387a80b91ee06e27c418cb8e2795b68a175e246538c1a52bb70e8437cb7787d18862198bb77e6f09006f05c28679132010ae03991fa21668f68d9ab929c22babf7bd2ce81987e2121f279e73b840e7895d03c27d040e39d2baf6ffca1bbc4e7b9f54d82b8f660eec680eb96569b4ba1628b2bb621344fc52e2ec5f7a963d0da7c6cad0e86a4fab79bb8b5bbe37a75cfdd0aa5621093937a8f3b2bce066fbf82955a23e48441ed118ffb7913000771fc8929ee1bda4234760cda2e30e22bf6de40874041ee719f42c5eddd361637066d3eb99b73e7e13c6ae3b288da5b5c712a389e11de6e03b862eee63930aecdf518e9e1ce4a76b84238daf18d9c5d81eea19d03e1521a0152007756b075608c7bbb168378e2801ab8b9adfb1082eec7cdba1174b3d6023086bc007d0070203fb8b3da5aebace744a39bf15b6c31ee0a88d8621c9de5b158ccdd5c211c236e6685984e9e8ac330d7c1317dfbd6bb8b901ed00eae100e3a8477b32130017236a9022d585d2fd00f7ab8695de3a95b3dc4803e882b0e24e9b4f9cca015e774a78c149a0d016f4bd6dab481a83d88b3c5d33ab6d86d8e62ef71dd7175d0d2af5f73226adffe83e470efc413740fadf3b9b5ee43083a1f77049d63d7e97421ec88b59b0d978a9e216d6c5708c7a478da9020c81a8e28921f6eb71a1090dd9d1bef07723ad36ddc7804a5b5dc4faa30143f0740ce59c3c1042548ad9b61454fdf5bb8198f40299e40f3cc2e14e3740fdd7d783aa98edce6e39e73b3e8a2df4a3dd7a1f1a40afbf9f9d56684d3139053c4844118628b47cca9cb1683f882b6109486a1b5386c4b67db5c8b1d44ff089076498a77d6100c0df68e455144677dc5d416c2879098c40e2774cdc1a0b36caf46851ede17a1d3894d37c433c7623b8aa0ee6d0dc4af16b41f5a4c2d167fda2c0c745d1eba288a239ef3f62098cb2b588bc3812faec5ee2006714d2edfc65cbe600e7fe509416b732bd802d00e2734b6b8b1cdcdc07ecdd51dbfe133daf2156d0185c0122690c021134441421c7efa8cc07cf8d36734466ef0a0f4597c9f891b4e27a5944e1b9bec81df30b56813f8e3c26714460492c0c101816ac5498393260dce95bd37f75a5ba4162df90d3f7d455d647c454d3ea2287b66aa2628cd5e1b83a5320618c4bcb85285b628ea89be22a9a0b40f7efa885c10318d0129808666c1d8df0a80c69ca8281a1366cbce5954f19fbe21af33be12407c424b2c181eb62140a1d51982c1033341734ae9ba5a020384cb161d3bbb62e8853ab48268e8a896a6a633c6c14c50adf50a04b0465f09ae24fbc318c737e4e46d7efa86887cc63b2496a823626c862a66d224bdb8da5115266082e267e388953221297676beec94ed94ed74b9350f143046570f292dbc60b1da55a62d675fb7a0f984ac98544a29a594524a69c525f48d7cefcdede64185f01dd31a198236c7540c6d20a8e37a14c5a9a3984e1b88769cffac1c4c48b263fa84763c59e378b481a899b4bdda3888eab93975266866b9dcc693a726d276da4592e214db7aa5b8ec98524aa9c599669ab336f48857779fd08a777777770fbaf6a74fc8852ab7fef409f1bc889011d14df31d7efa82c2bee6a72f484a0a72e2546ac16edef99d11fcc30813f09d0fbea021ef3f7d4142ded2e8714be0a82a60581c2bbc0c8f459091fd11f453c3c6e8f062896431f372275a55482c90aff290aa35e8f02f19568616342c3912a02322404055284dc6cf816c01faaa4e5c350c9650955dfa6179c48006aa7abda8285c70332492fc0a09a1eaa34cc502c6dae0628180f91914efb2244a912e20354dd4520d214e454c35a0a8437c3f43b63c6387ce808c81b9e24294ba9555531ce1a2c1b5f0f02537ea94277b4385754ac38263a529722869ea1931f6a88ba50aab6453aa112741ae2c12150d33f8560e3712c3ce600155ba1734262c0c684858136835499947d1625750b145b678498e8654123e4ef48a66542e1736470b967706a9529d097a42c6b2f0c5c98841a9e27b527f28b13f443cc9549d2143191a4a9a6a9317fc8c99135e65a644a561c6a230b3356af03056fc4b971dc2448c912d4158d851c9d8a8666070ab14564619a516ca10f91134152ccc1899a361c921a5423511622544aa87854106470c3230ac0b322b2a1232bc17c818d528323fbe658c7df2525b6469e1c5a4d503099acfb148d9a8341df6449a8cabb416b685b4a519d28eb2d2809ca495b8e30fe98e5b2a953b7ed5a13b723ddd11aba6ddb1aa6699aabd282743b36183a03dd51a682b3c0cad742e68479606b4a06a54a696669e66cc1a61a96553c668799324595553532ea2ac903136eacf98a70a63cc0a3163caaa64cc51e5322608ac4c0c6636682c0b164733c51269f99024564555dd31e555a2ec94181bb58798271c6256b89798d2f6c41cd924314126caa4997d8d616181618a15ad2a96c49954354d5526513184b10126cc931309b3a2060953d625618ebc2b4cd091324e655664cc0716f74d89a17596a4bea8ea326599a2aa8d331bf5c9d953b572b6c2b5ceca1b67474ee52cc89228e38299d53156b560b19af2d3922189adaaf232e5655135c946f53d29ad102b53981df99859906dba6299fae58a665589cccdb2f8982f1650ea8a2cfbe2caee18f27907ffa67e0a981d9f77e6dc69773037dedd77e6ef784fed9c02ccfc88803f2643f6c78554ad207917a4b4a22f2488be148940ca6838aa955d9920cbb48c6aa45c9b57d5ba355c3e5f2b655686a604e68a8e6cc942ad577e30ecaf86d12f0ae927a48497272451590aa2b226a4231dfca40a3d3ea4de77f7fdce4161884db4090571e7599e132ea1edb59dee21b1ad6683e7d7e06993bbd972d373d3a3a6aef138796aaf758dc3cd1c9ae5395193a74ecdda6b9e2ad5ba1e7344f0559c39e18798664df9572910b787b829758bc9da747a05c977aad6892e544b77d89fb4f7e1bb55eb482636048c53f3ed3ddc9bdaed86f1180586fda459f906f6532746d83cfdd373fad6ba1a97e27c136ba2f7d4e0796d3346183cd46efed343e25ceba9c1f9e6f38d66d5e4fc87667dff88502ec5d96b6ab379c61a3104473b561f7ba436a712db26839c38b931fdba59fc7e5a13dbb35c12ab6f6ec82c37bca989e4a4330cd1df187cab7af60b03db0227759bc62574075a3731112b183fb16d5a5212fa390bc349eb2f8cce492b58a64c3f31b8f413d3222a8476f633cbcd534c9c61df359b4e3fc1bf71cec177cebf842ea1ad0571f8e3ced6cddc6c6f3a569b7c83ef9c387526aea00d7122e933c351ac196b13972f887e3b7542b1e6dddd8e1b976b6f1b67732af80d39d6c65ad0ed5caed5d49064ad66abd96c686893477c68137bb227c55114c76a83719e1c6b35361fdc8727c926e9ac3679c4770801dd81b87e1ef133c0d156ef71a4e2ce06327236fd594326b5910af9420d9935d6dac823b4355186b57129f64a86b551c6a555ac895d97fe14479b067b748be2ee4bb726070e26609db56e76c0b128e27c6abcdb84735c03ef4161e6388ef263a5e8279777c73d5a07a68ee32c0e2624c16adda4ed36fdf3b327f6138b3baee34ca57e6270c7753c7bc49d3fa50ab970dcdddd9d36980e7471e3ee8553bbb37c082945677ddde88f5361429bc0a8144a68d35777777b8dca0ad5ae50a9cc2e916cf28369767dede874a00b4b4fc0360a7e72830af41b17e0e74f1b0106e0a1030802b80500001fdc78d00187bbc1c656236b463104a7ced4993a331c97d0b9d91d66a9b5d5d65aa918adb57230010b089eb4d25a6badfa8431a86f732bf8537cbbbb1b836313518bac390560ad2028e38260b58520c0d7e6b12e5650cc550d80b8310885b4966232b4d5acb5361c6d230d6c6823c99ab1a6e0434c86353297eb885a33ba2d84886baeb6aeda1cf706b4b3d69ed2dcb5f7760b475c73f9de605caf786210873831373119d6400c428d855babcd2774db0915cc8d2feebdb9811577eb2c106b2d18926118861604adb50d6eb1b60e7141be7daddd5afb6a6f5020ee5087563feb66156f0ae0aac175ab32588b6ded61885307e2098ab83973c02ad64014519b5c35b86a3c08d6fe17ceac3087df8236df9e1ace22cf02a6ce628be9e4d1b56ec7731c030b983c21a6ce6b40b286a333c78e3470db09e283e2ccb13884e31defb933c74e5d0d763c8ab8147cc50f62d2d2d936997ebe63d7311bc89af3709b94d20966f1eb9c358bb87910b7b598a459b4b85ce7d4e97cd3398a53c1c19c38c3f12bae984e11375feb8d5beb86dff0f95ec0becde9a68ee350ec525c8267ddac22ed9bafb86d211e90024b4bbdf9daba32a0ad49d7d61a0bb7e2f9960335b7825b9cf8b6dadc0afe8d55a08dbd28e9b9cab4c1a6d09862b7b9896bad34575b477f80b68783de534c9ab99932e539752a9e3614bae61a376e3a1541dc75ec02ef0971cd65b1e22e8d0bf6a0d8678a8682efc29c5b798e6372eb523c7f9f0314f78fbbe1a72fc94892905bef8c60efbfa75a8e9a20e9b29b98065d3af53349d912144fbc60f102da65cfea7996f78cc0f10428878e29de132d3b8abdab79e88f2981fa30d07d0a16b76779182ec423c8baefce8ead77b58e7a966fe9b8def31ddd43b37e7e7e9276f46a8c72e5f53d628d59b5cf6357d628953552e5d1ea1b8f3fde33420621478eca967a642a7c7c1ed10801c930962388d58f5d1ea53e8f5cccc8826250fdc89476796c9ae1f308f5e3f3d81b9d86e83444914c3cfb16d17a62570fac27f68dc526ef1941c41525146449ca89965d8fcf2254094e1451317b81abcad22e8bbde7f159945ab2310313291856615ebb2c52edf82c5ae5f82c66d53e8b5b6e24a6702316df2292a8f42d32b95288e64ae28f2b8945df38a4f29e0c50195941c154850a47d4e7d00acdcb0f6d888a18648c763994e173d8f5419a58d7982638a46eec720816c3e750ec1be7f0f79dc3332ea10f2e403ebc11f6be43a95fc8f40b9b7208f58d4130efd99df1d01c3171f165c5aef7191403f264e5c3acc8458fb45d067f3a3e8325644941024a0c5496c67639fcc9f1392c7afa1c2a7de770c90746f1797d835d6d05626d7557e7509c4120df20912226108ae933d8db65b09d6c3b594b66cfbe2d1a94ed82028312fbc6b6c97b70616a8805e1b9e094b6c3f1d942fdb2c0d08218d989a530bb6c7b373e5ba917f46021d4ebfa552977d952d9f86c93963e5bbbf5c5a6f8c2e2db32a159248ab6d415aded4fdb222b1614315b5241e30b0d5fbb5cb3bec6e7da55c592803ed75f079feb99affaf001f9ae52df5637ac767455a6aeda942bd4b70d1211510d53c20839b3a3f1d9c51a906528a988578d2b19bbec3fa8cf8e3687e0f855212b222ba3b4cbf567c6e75a44e67355face75c9c9a338797d3bd6379ed9b3bebd0bcaa5a09c2abbd5f70748d07ca1a9e245e26827e3b3174d2c4fc6783923fb6105d965578af1d999be919c8a5859298d9c8676d99b1ec6678732fbecbdefec3bbe49a43d8936d36467df3837da77517781158941b5545b957deeacefdc5b28748ad984c577338da091ba965c8036c5fa2777d1f7882218594e7c2ca89a94ecfae933b5ea12fbc6999e7d8b407dbc0840be33bdb1e3bb31c59932d14ca1c4e692cf54e9f624983c74ea46a081ee11e9cd002f7cd540835262266bd7308c788a21a5055a0a264286764e6f020d5666a4317adaaadaed80dfa18ea1dff021c609f12df4e5307bd083073169f3016b5ec435361f71b4f98461929b3deb291ea7dcec3d17b4d8f193e5cad64fd8aebef86a844780af1847d73d3b370fdd8367bef910cfa60f710d8978f9d05744c88758b4f9847392a07b1087361fb01fb4f9549177b32b551189c216ff7cc5b6da7c2cd6cdfd7b8ac5333777efe611e88e246eeea2a7588471c5a79b69d75315ef8e7174d5aba4823e003f270ffe5a9fda7c7ce7c9199774bae0970bfe2e48e68a5b376bdd7c7b3a82f9af005ce4c4c9f4d734e2b8ee7ec5dbc5b713466ee01b751437d35e4f14efbddd684e7c0a7625f442f64ebbdeb193354f57f384b51d1228ce22fcc40fa05453c731eda224d01cf5cd06d02a2959d7437b9ee378da9ef6c42b3c0e260eb98e33edbdb7d31ec5b4e7bf1a14f2c7a55d6badb71ab00b7ec660d5a5528da9786f524f73b5a44ba52c879bd6555dcd810921432e53023350214c9306edebcfcfcfe94b127b9a5bc15f9c3a14739812982fce408e584413229c604235bd672a199af1b39b58f44b49e891e8d2af241ad60a9c5a7ee23a3db84f6e98deb5d635a54c3e14c7c34d9d019097a844aa997272162a22190d00003317002018100c88c5922808a218dd0714000a6fb238483a24264a228114c3400cc43000c0300080000c002008033008847188297eab6506646f68402d92f0b15e3937dcbf4bc703d2df4c152cc42c9851cd1d18bc4bfba84dc106d63e81c00eebf99a347f08587f3d9159c989ec4ed73d458df04a00136307f26d465f7103c2cd8fa1c144c18c9d0451ceda22a6e80453bbd0e98f952c04b26fa6df8f094337fa2f36c6fdf81de387c4b377b04b7e8376cae7f35a1d7bb92d4f6f0c2ed8affdf109669d0c37a85ccac9aeb13364d445afeb96b33cb4cc8cff7f65a035bdb2320200c1c9772f061ca039209a7c37e5eb6ae0a9f791e277c8f879999c725fc53ca084047ada8bdf8714d329a679139fbf82c978d4885cbc1d0b8f505e550df5939b564bc49edc01c958e2105d7c758821ec0f3d33d1c62dd3b5ce07d23a6a0b3babbae396b96990c9a0c33d0a17ce796aea41256fe4d216cf8aa9eae002ed53a14d3ddf81f1b64feab1b2a373d754f63f405a6e733c1419fe3d75f1ac08bab4884a937142c5a3ee482fffd55e617c4dd1fd0ff231e887bdf78d4d17ab19db1775e6e67f1a53138b74476f3336f0ca4b3132495894e6ca764a5982227710a299937ee67b6ea9b04ef3cf739781792781fab2d23f60327d2a4b45b98e37f54360e88d8c582c9e029c862f7c3b9b54576a1fce9fec9ad08a387bfff3ffd0d06773327f3dd6b29d56b60de594caf47506e3035b6c3bee1c25fadff5e15e36b1afb19141ccf8c0012211ecc005cb56b3f0d161471368b2fa6563bbc4288278c01613f08d1c3ab91813d265a69c33e924e8a645bebf2f94bffc136eb1b50c15d9b7fa7e384752fd20a7fb1fe889b24163d0d0008065a974d96200b878f67a1a68d49ab74ad46781167c53ccecbe3bb2b7c149081ef484707a5a03570d4cfdf6a069d9b2f561b01dff08016f756b41e24750cf5c5682be09bb11af429d6ac48e4bd3b8e5afed0c8868a29e96b77d302bab101a6050515e46a83f3926401e19cbd8bc423348512f4139a72bdc51e453144b423dbea5f131bba128a082dec3d2ba2aee50228abc39b89af9df92bd583c96504726eb90b1d75c9f57aa12408e5dc8a08afefe8481f64c16a7543da7680fa3fc41201c974d74eb09fa69d2dbfd4936e0f3d4086aaab639dd39c33f870458898efeb322ca6ce96b3e3df2a5d36ce1bab3dd1c7a1239d827b977ee3e4ea6211d11b51ffa7a95f10b4706a7f11b1c597ced890ce583c68049a3472178e29c807017e11996e84e7d2e7b2a80b667a8f8d9e73f76f5dba0bf5b065c563ab41dc4e65ac6e0d608c71bc2f5524e85c3778393de80f418dc344f1b7bba636d8a2f548be1e5bc6262d3efdcfeb231b2a2a9182fe2767f3bf4503798af1d060ca1b51ec8c7300dbd2b0eccbe825df944d0ad02b12e7accb96658042023626b2508123b9e4b4af928f985b283de675e9786fdf18b5e6217cd79858614492212c6d8bd1ea455e74b783fba1b23cd5791bfdf3ee729389242e624fb641fc5c65053e3a6cf8970b6e5834df923b3c9ff95920ef6eecf79490a0e0568b1b42e3db64e96ef9418954251ccb46c51eae1b2418fae9a444cc42845705bc238da3ae635d9869f54f2ab7d1920c175d034b58c916787094246494a1f26c2300f9504b1b9a66c26ed19e656561b473d57d6c7bccbdff0f1050ece81ebca2c55847e5e992db7b28f285c8be58a8d991fa56aea4ee658d39ed9694017c7b8cbf89235650e1b8b79c99d1ef3cc289aee29efa4460aaea880c432dc1370c865e0570f2b551f7e9d74714f7cb4d483511d6f3318811edeb951cfd3f3e0a4cb57afb1e89b70d0464f379ae3fb760d902631df29d197c561692c1101ffc399bdf62a2573cf34f41397c179c7a51997bcc25749d7a2bf4bafe4c6db2e583ea7d42874146f4959aee7dfb5a2054dfb9bcf674506d6338c0a7b52a8bde094daddbdb45e6381b066eabb0e1336571a5b8448808458a66c8e973c3ff935e56000a4124091cf2b0695abe5d9367e0af578b3dd85e86ca70de2d43236c478ed31edcd3260902cd16099f880dc11e6276917b32842c3b0189b6619872d86cee17a01409bba25b2fdc3873672a1868c17f674741a505c68ca7d7063304a4ea632d913fa6dc1a84d2687e516977d629b405248e98ca5dd8b0fcc0df96f98cff4ea38b30bd898d24315ea53883f5801548cbd0bad5f80e9eea79bcd4e4633b2497309609409bce848043b4680f58433087e5e4f93828f7312536ad47cfe8be0d1404efc040309e44e5de5e28e9d27aa27caed9acc732888bc6514830321a06d9b5107d7738416cde75d4dda6d9b7aa3f0d4462b2be6bd754dda090b044534b65ecd7d6533ab049833aa644b3d8bb9fd7ef0f81b71560ac4c6fdee1709cea519dec996aa171ae2f0b69587a9f2ca598bf1f38a26fb6926cc98e9c3ea5f10752a0a190d261fc882cae44158d07e17fbca48bd3a931f5259e0a56c76929a3134732c3663ffbf94cfdd4518d068ce5309fee2a25072219ec6d51fa1e5574bd9f4c23deb6671137c0969a5d2ad27c12db579cf9a7dcd41e2d6cd9d714efcbe0ac2a9ae46936ff16e05b66a08e3cfe4d167403905af34612c61b742c9a3297792ca093413d971c2ce7d89479956ebd7e12e3d5ec4f750389814511b99e3e7c6205b1f08e06059ce35d77668729cb1966582b04b5b2a9824ed105806f814c7ec90fbd12f7d0abdbb9b4405ecc867f2c8606be342cbde63d480f1ae32dd841d886876126ea4b38e935a10d861a9d7aa85a3d5165ad693e4778b193cb9bba94ecedb5e73991dbc76449d67cb2dd7280f0eae6391aba7e3fdcaeb10bb0f2ec9c6c54804972a6d87ea570f4a1ba286ae3106e66207208a88bc340087d26e46955c9ba4461dbed9cb406d9235aceafa28547bcf9e8abfaa30b9d9ae83eadec40d1bc7edb48871b57b5225e414882c3a6684ff8a1e3e0f38b4f82ffdfa5d269de3b1b2c2f6a00b8ab0389c3fb9b00d1f6244b7b812632fc4186b41cd1d615d7a613e4e36e8e3d3866c28c662762405852c31a9763885f2795fb21d49b8c3226ba8d0ed0dc3048d08ba6778de8b67b33947fd12e9d78b684b66076002d3c7f742939ccddce36856b27844635606fa48e5f8d4b8b719846862a70d6e0adcc234c67d6bc5b675249ffd61918398510ca3f4a8772f39df8402bce329c19a9594aaafc30afd8a129f39bbc5da5128c687c3a73a4d2770b91a6da07e2af63b6d282fd4fc57e7be8f6556cf01fbdd61788d1d832a3a2d8f77e8ab8302da778461310450e17fbc73771210bab0f69617a0d05a34c1ced5a5161a59e49debfddbc8e23983a37825ae104994bc55376faaca73a9da5c70dd6efa6a3bff725117fa95c056f81cbccb2674fdcbeea40f08ae4e999c3de1dd43e35eb475dad1bc3a9446c7e91130b95433898b38389540d6577156ac187be85870a336df8ad895a9b9fcb6a19f875bf295b4080a4f0b43ece8bdcec5941d0333892edbc99fbd6a9b66e692e7be6cdec510d89d6a173bd243f7891729d1411f295d85409f4d81d3a812e4ca2a37a9114840225e777289e8de5ed6731f5f41a32c9b125d233e30220e07f12009273c8e860840889f4eb8d92f8bb748d8eb4519569ab7faca296f795bbd179f26abe09a2f1af59eabfe31d9616f9dd4efd219bc2f15ebd9b54d283dd41a9d70bd69a09d24b134223412c0b9d71cd3c4cd072f3cae085d151b1957b5dd55920c39f93e726a9fa1e6759f4c8bdf2934bd1d2b1878c4903daa4903d39ec3135a50f169758d2bae5ac4c31ff6c87461b8bb904b6f379017ab823dbd6dd1a4a083dc230c86a735b61dc6b642f4727fc0887640bb43d1c26df0e26f5d18b21faee6a239763686a87c1ac6832a52ef72c77bd74cdda49df877a9c2a585eb382706c2a06c4d4fa2c1a7257ad134c756b864cbe02b0c31d196600c9247d801151be9ddb25b813abf18df365174fea90f85551f769062ebf60b049c0225722c827153d620c6a5730f96763eda4060c5521c2f6a2667236c98c40bb014e64e91cbf5b1acf5cc35ff1d4e5f95ed338232c6a9a355245237850f7fbdde4f4605cc18e313b7d36012b42ea5dd6e0386f8d5bcedbda39d74b784d6b55d5296abdd08616528a1ba99a6a0245a5e7a7fb7640a5f386d7114e7934b742d589d12bd63b632413d05c6a513ac48417d177173c955f66e8028b1886494d854854546c2e4057909e28618e2364ba8c32b9d459be403ebca058c4af5945cecc5c187392c0aad854c6a2d1a16e584325de86c61c78130cab1322e4cfd501aad9d56b12de136ef8952300678fe09889080206500b5cc898efbebb6451e7b6103faeef2287064c0a002162340e8f07cfe19b5b71c7adb25a6f0dc27cbc55c31e4c4afbb0d28a475dff11b0abe0cd02e426a0014079782ff60020739210ac7403afada9ecac873f0c440b01afcbd65236c5e566ead8f96bd1936e055d9cfb71a12b1b2364af5c11aa0b6d229fe9e5f71b052ead129beaadeaecd4651e858614811b8241c968699c5c4b5067174d1244cb6ce1597804d8bb462a558ffcc15f7fbf59be7978453eb7565a086d3da4ed3633ea14c40aa1e17bf525b7f762ab8823238e3db3c9973b290054e0be14b74dceeae321fa3bc8c011805dc8f25955c52c78215a21edeb281ab10c468aa3ea6e57fa65a11918177d57bfca0f83bf2c11d86e1353a2a410d467255e9a4869843d6025ca2a50cdf40acdd028d3800ce4581d1013b4d468dd64902d91aeef818c692f401e1ae0fe2a59f362152e512f44c7706b4c410dc796ab52bc9908b057aecbcfc07e87d270af983f21aa2af563ac006fcfbfbe5f094f7f314c405ed28f9d74ce61ef4c423ea386109d8598ac3b2cf64ce9a67826fe00667fbefe91cc993c21f9d49484e93b1e5ce95df24377c4e783930366db9ab10a7947bd02bcd3d0b8a041311985cb53eef7738c63228a5eea5551b53a4330ae6afac94b059b2b11ad02198a8ef526ccc224e53b58326504a637613bdc4f50da55f2668be4ce0dc48e08f982ead2ed912ed8bcefd3ee200ff77b2cf2cdd37307f40b54c17195603922d9c99ee9328e7010a6dcc46c6ee4c17eeba31a114f710fe1c41ff84a2f4bf7565fff6640c61c2a948ec2a9b59c005f39c294d9a514a2245bfefb48799f9a046519ffddecf5daca8469a2e495e716f9cb975d4e00ed48a35da52d83cc524998196c0b722ef3d6e800fb332a678e1b2af7b949de16af253cb1d7800e737f0c7c81697ba1db40031a1988fd281a542f932d0d46fd00b740daa01d4d219e2f487d02b8f6f1a10e46ba4ac8caf226f49c07e8ae85c002964cc1aff9ccca4614de20822cf5f8ce275f7b403956981e5a9ba016cffff84af778adb1d369245e435a4400a877ba9502cfe1526bd0b3b27e7ba5deab8efe37279629535a95b1646d0bfae7ee28e77bded9184276f62482d7a886c0b6dbf4cdf952a14309035cd96f843b6fd9a0d25ae2b9974a740e530a316dac7f6b371cc1acd0f4a1809dc8681c70fd4cb0e03bf329292b8657c7ca27bff14fdf787091d56c0bdd0fc3b0265121ec4080c03929245034e5caf44d524db34293474e43a6d01d052f1930e2474b6decc17f4fcadaaf02028b8210b17f07c2f5cfe90fe40d0306035b3fe40798389b386b3af3a4475f21b77e7f07db76a8d959efaf7589d521cc906ec063ca950b41ce978cda711545f90384ca6542d1ba095b758318bfe1e6c4fd5d64e39522f707b8faac6cdbf098de92eed676ad1a0a2ff407fa50ab6a5992e9d3c5ce556e44aaf32f56995a72012ccd5fe8d50190625fc2cd3065e902c2d9c54f52a703d7118082a4abbac0250a562b549dcb37438c0fbc337539462be347d6e2f545fb6dc917c15705d83770520c49c87c92da2da81505ff1ac9eac61595d6e3da6c2851dd39d5f7b470f06c7456b066fb15024dd44372d722a1db70ec6e2ccceb061081bfbef5cfd17fbaeab360fbe80cf750f2008262cb40e5de48ec77d58aa3b9e458721430788e13a6d0277630407c5e68e5500e4fa839fd0bb968c854b453416fba69573ad537220706dbbfd3d6f4f9bddc02f08cddded5e6bc92994da47c2fe057f20d16367f39c3453f32b7393b6793ece4ed9367f0112e45e70abf75456abf7f55faf079796227925fd96181099532ad33ecf2917efd0fa02511dc93dacefd9738624e7e57f1403b0f349bc422aba9e2c59a59dd9845f10922c5ad6a93cc990f75758afd45b34251fed52609b963a97276b5aacd57d4410f5206b97f4f2a9eb4849a7f246775f4724999c4f2865b783b63a991006af4fa478cc645da4d322f36a0b2fcc48b5af01161b7d081e46416f0dcb38379ead63938eedd576814850177ca5b9b9cd95631248c6230b5045f7b783ff1384b0fb7bc9785df9b82807ff3aa8be1e924839e8c024b06a35ba70482c182cac86b0976a150f80f846ca198170a6446897e8765529487b586b2c3e092e53f138b80521feebaca0d661ff79000cb149c136dfee54494d3bd45f4185e97bb61d300d297922b65fdf162d22f8e4d9bb0db551729cccfdabf9ad0199514db7e4daf52fddd6bff4457ae41c480e6d8b5e4680df1ccacb34bb83b31584b0123f85ed1f151cf7f9534c939d740d02f0927450681059a78a1ec22927e979e14e733da107bf64c264b18fcb3a611a0b547855adf70523c008c99d1a3ea785e6fec1e98f294e077bea62e551ceab8282afbf228ccf755b061ef4bc86a7879de60f51ff6f28beb55f6f67487b40d7f83b43b64cf72fd785815cb4b56e8bdb1c946e1d6564d483635c50e026934d0bf23e49844fd8640a2ef7459db73ad4ad05d8f38318a0a4d3dcc6489451c9d7128ee47cdead594ff11e306dbda38f565f8a663496dfc4b2027b2c32dc11dff98c543308f34ca45ab06939b94a51365d06c8aee65b8b0c440f2f15b464d6b681aafc7d473af51d08a7e60a1750322abdb272410fcec20807139d5ca5bcd07685d3b4058a07042e350a8374e5acddccca8f73fec0d6f9fdc32dda69264afe3ec65347382e75efaf8a78b3777ea2a679d24169916fe738ad7d180e6bc9354c94eefc4b526ed3a0d3756abc736c2f3e43b4adc5e60ae9f153869776fd205a2d4469952c648810acb75a28b9300b72d2a20e44287b457c2927854efb7ea56119362dd8845dd9da4f884dbbcf17c0e1e36f156b26ac8c8699194d58985d3910ac909f6a032f02a47a7dc3f1eadfd641122fc54a96d53882d63d3f3d7c23446beb254f8e0ea4a2f510ed2d1d338d3762a01a8f8de86959b9f97203add955162c45301ae67e62647e1b8237af4d74b187ca3605445707b00db8c10b49e78814c5bbb292aa24e1b25421b328a9f3991ba082523a1262341c5f2cb3eadf3e7865577a26069281a868526b98ce56ebc1576b7f87b4d8704991695b4835383eee6f7f2523ef7dead4610c4de73c8db4d27e8951b4a06badfdb68d4fe133275988ca0dcdd4cf5d7874a5703dfaa9ef51d491314a1a97292b8085b92553572f9a30ccdcd96fc5cd7b26f166d3e5de6d79b0f1b859abc9ef9407c1b6862d58f76f767d56ba8bd7ff6a20e4567d6a396f2ac855a82d41eee5dbf741b0fa395b328c2eac359f410a20dd8618dbea30b7401b1b6dcfb374fc26a5d8fa8b5229272a55695203669852534562bf63b1d74fb5de864f729f5e6bb4b721e281cf2fdd21fcd4f2f1db5d554fcf6589d1abe8a8692524d66dd7cdd742cb41ca4d9e78a46db4923625a9e69e8848d960de1cbcdc7aa93e7423cfeeacb345c6f380087767784249eb992bd3d1a47858e2551109c8d8ab9865c7bbeb7a5c9ad3c08d65c1e5111c74f03d69eeef8a0c4477b5f64a59e6e1c8a14641d2bc69f24a64b3b4b8b442ac2f221f99263370ed61203d1bd563897059b74cfbc568a149873368e282368b133db8f74ec70d55cb33fa1548b4b28ad3c21832acfb11f69b066c7faec63955d3576141416878e075e3e42b2ead808f4da6b019e7822b7954807603594d4c721e310f2375cba37ec953b0d3966d136f5be8267851cc9a087d512799a8d67887063bd879144125a9316aaa9ab011a51d4cd35e54710404fa019c6d92aa6cc70f32c8907ff2aa1964e32ddb9928aabfc6262708b3a9452356be2ae912dbfd918570e1448daa862fd8c21e66fa873aba137c98c34b00b44ddc95485ea0273218a83cb4d2597ca7c049784988efef149faac63e9baecd63a05ba5e692100acbf63717078ce9a960068009607c231ab6d5760f05ad59aca871885ff68e7f3d77e40034cb4d4abfe555cfe2fa102bde2c687bf7f60187c1e268e800268b44d068ed70e847c504dfec4c6bbf2ca1c3d30db42723155251384505767eec06253bc3bd4305e8b63719ba2bc1666f802f2ea584524eabef844f4251ef1bba2b536fb8f29fde544854c53c4b2b21ca1d29e4b4e24329cc1e67db989a603334163b3d95fc6de5e3c0313f3896e743ce429189fd6b0fdb1f5b83f0889069c5c6d08f04cd0e33fdd19b1904293895625a8df2f2adac8cd253c6c821f7478c2dc46313a2e15300090cbee9351ae2aba24a9b262683a3755609f3d8b1f644b1b611b1a73d9e928f2c5c94ff4652a423f0aa05e8ff7952e4bfc3819b933387d5049b06131fdf1a18e4988395c49e2964191a207e254513c15e285842c7d7d28e72a3814a314f576cc118f083fd241619d8955a23dae5890487b2620a6b73441506786d1cfe4d933f175598b5e2466d630463292a8af8358aa85695d16222d99b16a7fe5888cb0c65e7a3d4ef47bb02fc7d3e4e4025d056f82dca23d3fe5e7aff94f451fe599804bfa99f6cd5728318b19fe7da53e2d16673267ec8f1dcf28f5d5b1eeefef10eb685aa63e5b133e5c46d3a252a864b63edc0b904132e0dd2f25407b3047411c9cd3c8042866662bd9c4415282dad73d0260a153a33b9e2405bc2d2d297b4b5029c692c1d22eda95f8ff812e88cb7f47eab94170d0beb92b0c9b1d4ad23031901cdd2d6aa1138929059e695328ab16f3e436edbbc0838101e53698f08883df5ff9c46d45b9f10bc2a1ce4805b510eea4e4792e0f86f981913abc4e90ff2802d2975727fc1a298abf34770ef9e00cd4579e68d2d0a95f3a96cf148ffb3560df7ce27371c72723161a05936e40ad90ef1b3fa0aabad4b52a3fe98e47b4a858b59c706d0357ddc3a77d6f60dedcdfa2b5bc6f0520550652f61c5f0f0beb47201aadb0da933ac0dc46f5388d0cc65de9374c3506425c01c514e240bc77997d6640f55d47d42918af01f35e54639144c7f1c01887bc581029d7c7b8d344f14ce5ba7243b9bdcf6bf54aafeb02b17a25fb26591d44849da7f7ca6e4e43ddcabd71691ac049343a55ba4210a86a4c4c455a822e4d6eb82d49b23a99b94f4bae23d56fe38f7ff969aca72409e17c5ac2cdf684da50d888d93cb3a510eaf8bdb47fa3267e2aa4f55af4a11df42ef952f607719f6e9fd60dc5ee213a0f8324299f2c6b46c1119f74eb6e8f63ce2f65f46ba85b7ef96f057a6971f61c4523418b4f668eea1fd91fcb6c64a6b66cdd035f248976eae1141b51f506b179a4fe35e4310853845d80fd18df823a205e4f3eb0811410c968f69ede2e4a331ee4b6a90e9aa887f5217f205e202444b1401d8a21a4afb0d1797fbc6fde61c0d1a28e2cd235431dd27634300f14e8484211fcff651880bcb87d69d2272229e1190085a8469c42e823b442762d0088c9a8f4e9c5a881fbb2d05441be217e4366710558d088afe39344f4554d1fad96d6481005aff485b2210da8360d1f9e86bf908cd235a5c7ce82ece117feef860df2e3a9f6fa78e88b5a89f97b60bd74fd2e58170232032a245ed3371442074115c116ec4e810a347a882f963bb7691fe583b5d44288210611ab18fe006d18d183402a3eea353870ae2a79d432a2268ebc36dd9114a8f90dcfc736b8c86b860ff04effe6c7dbc1b43212e2e9f7ae7e7080ceee7f42e68c7e7bde1016221b08942503ae871c79616c18ef822c62050a27a7ae381c72c8681cc7601fa4c382284ef42bd7fe83616379fe6f60a823971442a8492a5f17820d68d9e1c40c794088c85cf671d8bc467bf61478c0b9f424af3590454cee7ae1127ab9c03602e4f157aae3780b16b61f1c1def9c9fef9c7011df90cb7ce212e729f497641f11fd5b70bee071fae37cf4fc056a20892a77c0c0dd31017ed9fde6d41d44798226c176145e7037aed82f379dc1308e04641381a4450c5075b830ce18c880e418f3047ec86e00e514f0446f4931e0e68e483837621f7397a6371fe6468c811fe444c0efd7cb782425c583f586f2cce3fd95b32c28de8c8080cda07274ead824fdcda45faf3eb0e43fb09d6a5f5fe007cbb107f8ee4d4b2fc245ae1202e5c3fd8380cd727562b7144d0d4cf19db05eab3eaf421401184214c11b78fc0e8fea4ceadd5fdecdb51cef901b8f18834c462084e840b51d11141699fe9cd0b102cf61f0c2d39a2033168a81d644d230cb18ba88e4fedb5c009f866abd976769dac6fcdf0eb5a8c8d41ace38798475c47e0416c46b023ea8bc018ff24c0b1187db0a45d583e877441f33fd1b50b9d4fdd2e5a9c1f03b82ac43f656785d8420c4b04d0ffc769e5047141fd60d9a5e2ea9370858b08fafac1b65db83ff1ae441156a43f71dc2ed29f95f37d842ac29fd86d14224a88a5080e8433044422644efba084035afcdc1ad22156687db8462d44a111f10967e2cd480d0a8069cd499d788d3538168b0f76da05eb735ed722fa337472207020b421901d61c5fff3a1d139c2fc281f93dbc55b13a78a0f63b848c13f13478cd889e846d0f3979fbdcc45fe3bfc3220a35b60be00bf316fdd38fb02a1c14decc161283ec77105b13e5f57d020f8036588350065575228a7205379842c9da82854503b55096add47d1afeeec85e0cbfd23a2276853956773cede7801bcf00109bf5c7c726fb198396d2ee966e91f728911b92ae02b442d039aaaadea4f5875d374906e4a4bcb9d591a4c761e74108579402dd7dd2d8e13e8fc9d2986c0acca619f62bb02733c7f04a63d25777f5345d27ce6db85eaa70c8e72f4cfd71b8b5b9fb6f50d7151fc3971c408fd0874411875c7ddeb392c58338174663c9f2840d3401b0cfad7bde3fc8506e9bce4917993a580bdd71916939bc73a02af1be11a011a28656d5686ba750789c4cc56de0b955b0d3f4ce6b15b2d27567d25a84ea76c84ad781700c86e53788a1638707f10f0a963ff154b6134f212c60c2c56a4acead5e42240801130648416edeee5858ba4991359485a4aa69b81d9f7ba786b5e24d44a9c626999369a156a53e3d1b232ff10a456013106302fe8bacbb82ad0576323f25d190d5b8d14f327f28800f46ef3bdbfcdb751bbd8cf830c326be5afad87f45db7f9dce8c32836fc4c169cc45cff3b64c5447900d7557ed83da5edbb48ba1d1b79fffd640a934976f80a362183851778e4f8489e17755603ec392becb1095b2d619e400912123d5e9452151b92ce57b4652f3749e0c49dd1ef965a2e2f38ec51d13005bb7e608652b0853791214392647b1b6c0d4bef6eaf29e4eb285db1679d23020fd9227fe4e9494c5c70632a657e1cd7307aeaca761e9786d7443b4ac8bd7911eb51913d4a76968cc1693271d5c7b666abdccd1722ab4f43c91b30173e1629cee81388575ade1a00ac6b156c4c2a06c2c55369c58b25ecd3d25d28c502b5f217f16bc75c2ccd2efe535af46756ebde04f3c1cd496b986dc679c4d35bd20c1fcf9670d4c9c8aa0e139778352021ad48a20163bf3142c5bfd33ace74f159eb2e590af3a65ec0e1e504145b5736d00f39a3933a944ed68b98958d2ea321b3decbb9d20bf1db60aaa7002da11fb58b086db7c803306360049f7de8161530bec487a50f22a6abc2895da145a4477b05772b846c73df767f9b588a12005522a589073460850ebdd31cfad070fc26a7ef7ba89dfb7ec40cbe2faf55f98dd82ccb252255ab9ebd3b9db5b873d21a90fe4d43f3a69cdc7e7cd2ab07c3151e3ee045560b535fc84d1054792c6d6fd7b9eefaba371d32101e55b36b06614639890a4a28d7e4f9b933c736bc5be4eb597db4feaa87231a93e64b05c187eec34b2f484d39a7d08d785287a2f4376ae48ac892870bf2809e8ee47ab9f20340ba45464190f7af27092d3e21915112aeb2182075832e2bf9c18fbdc979b2a7f7db0082f712383166e65a7422d0c28d363094ea08879d3e67e85ae0b7830e86a20ccc52c53c82411c85f85e33a8aed58c9f251c356abe82e701ba72cc48e3ae38ad3f8c50cd40b8b202c041912ba6be6b4b5c2a85655780331595e64f4ba2c5deb5ca4f4afce5d0dfc33a9d6f5c5772a9562838a207182da109a55e17a7354999fa8526338fb9ab954932a30d2101d3507af06f527c3143f1566226dc649900d4453bda6f08f188157d8d46e7a8259c72cb009b2be7be3225719fa831106129f1afd9324ac0a3a49cb0e17fbfcff9a8c53264a3a07224368a1956fe96dd5365573c5d2f347940f1dada515887e8b2f430d63be3ed8b977cac2e1400fa8926ae66d987411b646312dacb5e9e602c4cd6c87220287f1bab45c165d4e71dadcfafa0167a33eee1cd51a6ee406a914911d4cf7612127853a6d7d849ff1c83935cca5f9ffef824e84174591b0f2db0efdb8a257d1bd13b97f0397eefc61a5a195bb0f5d97768c5ff500c68228821a391dd1b52987fb156091501d9134a99885d9ce3087bfb5c67005a0061a9cd4c138ef0486ac025b8d4e20f6f4b6a686b009137b877541b8d5aa8987e10b3938edd7a91ce75c8ef3132dbb9c2a45d14ea04d08e236922ca1cc2abec1c3b4914f516878de674e730c419ddfe68a380ec231de39b0f44ee8dd0a5d687a57b498684381749aabaa6b7f977b580319dd1641d9aaf474eca8364ea5fdc049289f0e6df76a1143dd6e032e89b4d454934a7aad094fc56031056552e299474aa4cbe53e56d56ace30c135ed5ab63d034fb79e6ac120b4bd0b416025310921cea21b1e1d0dcd803ba02d3995a30124a4a07ba3d36aa7e6401ab2ce33e892682b29cd8cb22242332d9dc43407465b04f8eaa10d28ddd81414545e8a5ee02900006a0ea988bd64d579f0bf54dea3e74cdf6f1c961adec13f08258a522ac11b2c9965b4a99524a016309970969092b617b3b5e7b5dbdfbe5e92568aab334cffcf40775c7eb5d1bd42fc7abdf0c1ace547fe83fa3d4b045751b90d87d6550b05edde04ec21382d1b283e6efcc13a5767f2154b804a10b7e0d1f113e689d240ed461bb766888d586316cebaf9deddaedf1798f4e5ae7cb1ffedc573fec3e08e909d65bde1ac22874b713545041c55085bfad8dd8436c23767df4cd647fbc6b1fa8a0f1b7aefbdefe748c58dd2dd4192e49251abb6f9d863c56d69fd743feea236fc19f941e0d55f8db4cde822f54619212b41fa94b7beeeeeeee5936e76f339bd9cc66967996751029a9bd32f4834810c95fb05d5be1f751bb74a056047d0821523694c516eeeeeeeec6181776eb1913fa2926a82a05ea2da8a9cc4ca6b2d293a6ca19d8b6284bd22a3d6962958a846a773fbab280557fb06ab7605613b2375dc4ea09db06d1558ae1a97e53e94994eabf75bacf133889aa50957f8647a3726b41b72b74dd744703faf563697595b4ec503faf328b0bea49fbd394d356a03a3a3a21301d1d9a90f8da2f6cff9bf361a79323887ce8dd8e98bd773a393c487cff21b02130ad036a16e43c6ff147aec75bcce1f016c3326e61925b58e41606b985394b3343bf7e9df4030df56ba6a4ce8674c323dbee7c193b12fbe3ed43e59cf6da7f332223068186fde1ae67b03cfd34e6fa028fbcd5ce6548cbb3655bfd9d2d7da99d29d57ece8856751641e191bfb20c1ed50c0e2d4fbfcc88fc55c436fcfb3324b21cf6d5583663621bdef51183d0dfa99e1e0630e00007d0d191513f196c8444fdbf2c2654bfaf528966b1dacf59a40d1422b54075a65604a57595706044fd266d226ff54b3eab8d32a2fe19bb6f66446d9411394c76bde42d27fa654e474c472c25b2a7d9645b0550edb717bb43c3dbbddbdbbdb5542a954a79e7b5c7d90d7ef052332ee8aad3c911640233a07982ad7e084cf543602f7e086ceb74726c8ff3385d109cdf7e088cfe10187f47ed4f577eca01798bff05e7b303ed2798aec4ea10d80f0d648c9262b0cf87f240fdbba05f3f45f92b02dbe2576a53794ce5ef334295a3fcb5306ed3423eefa325aa76f7d1da51edf26e96a19f57551c6b2a3554abc9d03cf593bf560d8cbfa1dac5df6bda9555d806b50b6c5531a159d5f1d7de7f955a00a2eeea0259f5587baca6369b6ed36e56373a4a5ba25f3f9fa8caaba4c585da9d19ba6d2554f8bef5f4b480d6f8cb6b23a6be35edbbfbbc25daff7995464f7b7cc27c135088d5d44b2e3be107adf0e3f2641c081f57e7fc733c7f4118fb50aa372f1be7cc10727797ce4518890c4f3238cd60c30c4df8e3987f7f144875573334cd6046a87e1c8bf1501329e8c7b128e8093f6875344b2c08fcdf84a29f3b35313561d3aead2c43d12ac940e450ed5a252542d5d7ec36f3eac6a417d8f5baca5731a1f22fb0ba804bd9edf24c4161f7f5cff7eeebcfb8487bdc4ded6a8e65cea49a4c3b6154c04c133ba0f3e711349b5adc2d908266aa27f0ef6e73f76fb8b2004e75a7e5e19750d08d62287f695023384ceb7a78ab374afe2ca199a27c703f3809a30266dcac06e82a1135d58f63fc3cd4ae8f568eb56b9588cc547e2ec24d36c97ddc4c428e6abf7bfc0b709d9f7116e09af5f0963b504b6e488d4c54bd6b26db04f51713d916ff11d6127642fdb530d657f638a6f540fd292b423f77aafb04dd97e1c2b679a1fceeee0fbba0e5d98750507ef6ded2fdcdaf0dda9fd1b3e34323a986c024a69ad9dee7a494c5faf7bc1e9ffa7d15a82c515dc4d43653bbb9a97613beb24057397d802cb9aebdbaa171ae3157c8ddb3e3ec210a15ae675f3399d32f1ede6ae7e12f8ed255aa775cd45e7f4a0ddd7ad9eb53966613a1bdde24f6c6016aafbf1d469f7679dd67a1fd99bfcf54f6c77fdfa75f402f1614eaa4ee92bacf47f645236732393d45416d9b281cfd0af2565bc0ebb6a5abbf6a10d4fbfeb749d4f8bc43f5e740d7d9d5589ef80b811a3390e2686c2b760d0d54ce5b2f4e1a397887c6edb62290ead5bbacb334514e9cc4487cf4b44edb972f3cd87607b6fe8a3f7d3a3777722c4abdf7e9891c0e206ff527ed08f2563f4c8342e5106e6eb32d0703424897675fd3e1bbf4c0861ec46adb48c56aadd11e8c39807e6d5bfd93c2f8773559eb81faf4b4d71b6154c04c13d8cd22d4bb293a395ebc79f3e60d2cfe3785a4105f7e90ec65a7a343fefcd909e1979d159d6daf1fc6aba0d84d6fb15604fd1f90bcbde176cbbbcccbbbd2d9dddd9ffb72aa4b08b74dddf7d12feaf12bc7bcd51fa31c73610809c731166aafb9487b293494ffe358140c629bedfae6eee654dd5cd55adda0ca67dda20a6651d62d53c958b7a9ca34d5dc522a6ddb54a94da5da52da86d3ad7743a71c9a2303b2bb3377d07f21f7754e4ae173f706a827705fae0bbd75803925706c7718dbeacfd9574f8f4cf2849947e5ffca52b5fb13a36c5886b5625a462953495e6853bf7fafdee094f150615da51b8cd4ef7ba28880163eac71f3821144d2c0228fa9110c142224ab555789c9992546f5a3af0299941139a56cda8cc418630433d378813a18d1211b32f3a44541448a8d4802cc5c21cd444124014a4d862aadabd424c64b4969363066b62092524a09a588981e322423bff3f1a36c12b1c800c9ee20b34c2912638cf197d428e105cb0f448c301159be6459867821e98d91c9ca949a54a9b1ae52932929298c9e2c514d061e96c0e0c312255b962061314b622a238a661813ab828b278e0c9185369483aaaa41113d2cc934c2186111434c291968d7551a328285182a824d88fa010d343419da92859821334c012c985862f2032c57e400d62395868638f2393d3f574a098ba40e90b2680ea56d6509fd3c1ad5dd9d28a9eecfeaa139446cea471ffa60cb624653121cb494a9620723384c0e3223324d91d4c1c88c51820193c5498349438512096566aee4e409d11b273d44c1449b8ef8f063a7c3f1e12f6c3f72b3190aaabbb9bb9b4847471096e208263f3e0b0cb31282ece373d6e92c142c4806059bda17fa3ffc50bf6f6a6febb66e7875955e48aadb7a80aed20b4775955e28e2a9aba4c48a4af787ab3f8c7df52011f140440d3f20c106e6cfab0c645ee82a2989a2c25feaadeeee1c361fed3184dddddded97d09c8ff678db74d7dbbddbdb0df7a14308e197b329d1fe0d06ff811820bad07083f6848605cd7c1003d5a070b33911372c52548048d540553cf44023152554e6404492263fd01895a682a0b37eaa8a12121f685150595709c992aaae529224eaf73d396c99199586836d3649cded8ca669c9b422724ea1fcdbbfdd2fb62a102641f97bbf597532a0d5feae5f0b6a47a705334313303244d9b2980141b49935bc10693094cdc009e4e224c30cf90f4c71d660a8292b87b5e548074938cbbcb4f16f66995295a89a65d9ff0e745fb02e31b28e9ce65c89aa1fadcc694103da85660585d1e4050a43ca1a1db44cf9e203bad555d2814cbd0245c528cd95188a38c0530e515c418508190ca9c18148e2200316a494524a1c84220e4988d0344f885ce0218c931b5c80491de0a0040718e44443850a01a64001c30a4f8ab8b205e6698c98ca0d92c8092850402852b820a594120a19a11b684908c5186384f24683928410942b22941fac20a71354986c549244155ce1e6ca982d3840b9a04485881116f5fb9eb9440ff8fdc54c47918d9aa0fede7acf49e9faf3bb6714bd030d9bdd7acb1b3697a01f1b453d61c36ddaf57194eacfa35bfc1f1b3935d136f40b48b7f86351aa541eca52fdb9c94dbf44e8967f13d5ddbd488d5577d9c12ee62fed9fec4f91f4e1251f1f1f1f9fcfe7870fa2e561270a6365c0bda2a95d3e40b0479482aa81ef6c94bdec6207e303dac3b13cfe1c631bdd616041f0f7d9f9788bb74c0ad53b17f2591e2ae8c746df425567f297d72d363232f2f7b1d3c886eaefd32ef76123a3eacf5518e9a8ea4c8955cfb22ec85bfc9d045b004a209f6083c8b20cc1c18b0d40940942e8c899271d56678a104143c316c688142258cca0c152c67b32252c5cb0146105e7204d182eaae8620bd31559608c831648814509305ca021b354c3b6bdbd5e9b2f0798c890ca094d98fcc8e5e8184cfeb600d6f83a18e0a21abdfb50c84161f28bb133e14585dd1439a43ac7625572eb2d472385079482f912a84901862627c0b8a003344f68737e7f34fb6f564debbed9f5a4703a12052ac284530a37d022668909294abc88466d868a32354419137544d21246cc26dc26686281cb0eac98020922a70aff178c14a400740ccf53e1bf0da4ecb0e28215ff098f94272ae76e2667a4bc4029981c7c514ac2e48831447850628b1584ee606c5491620b28a89449218624d468cedd308ca1148c0f021043873829420aa24d181562e0a2c94aa45438687fb649d084c911336490e8c1951a4491329dbb61781e4289a2235ae02284142a6881c40d73eb82cef5a3852f42bfb67dfcb5f0219540dda6a2236fbcfca0c4133280c13315c20254082184bd10d60ce6c85c1c9f7aa0a63994c5a2cbb1b663cd68177f3f4da598e7ceee734ea5b8853119390cdb2e80ca0c3250cb1a6864efbec9011dee684e842c040e4fb23c19f5689ab6dced08f3d75bbb5c7c0d7a77198f2ce61f91cb7942a5eca6ec67bb2ce3f71367667667777766e677f697a284cc814b0e517595705053bfae120e62eabbcbf6daf3fefb9df6fafb69bcb7bc3b0df0a6ee9c333253941ea602d4558a120302879416596c978df5f899631195d9f4d6dbf0e99db29f717156198d3842f7936a20e5052a4f6478598333903982f6eb2def72ba256b5845ca7dafb0ad802b6769285453fb49e8e12f8631d2c75d5837649d61688ffd49d57e1ffbe373b5a044968fd4fed68adaf1845daadf467541e2b62ed5ad1fab476746689a28636870677686ecbc4df808a0ae52141feaccb2f1ca1a688d1e9f76451f9f1ef85f0feca6641fb3afd1afecfb7bdab5393d3e703bea4cb4bb2b995092c2830804cb1a58ac2934c66ecafef7536ea75bfd5d64a0fbdd4ca250a1e2a1c7a7ec6f4c2c57448595a98db3ff5859d67d3f62951d8f9a7d7c43c524fe8f58e53ea534a75bcd04ad4c352128ec6613ba9fb5b3b051fbfb3ee70d8e5c8ff634d0237e773cdaebd1a35d117ad18b9eb72dd88307093c48e8d191478f0dc2c1a35ddb44c23a95d0aea62f87f684e7d5de9d340e11450a950d07424c0404489076f98e46c2436c8609470940da0b02e40afa6d9b18901e3e96d0fdae4888dde5226e38c6664d14949acd9d6971b417824fcf14d90b54b2a18cd4f1517b2b1c1d8920cb60841c80ba4a52905450926204103b6a787094a3f6b2b4c74847ed714a0afaf111121f35c74546488a928c58edb0da225229d25e2f13194a427bdddc714ca85db2eb9752ca2ec62d638c85ba078f22ed62a176219901eef84b29fda52f3b4376eebcf6fa7bbe1e1c1a703173ba14212865882edb58b18d55dd9f61e8fea4f60756e731cb67aa3f2f51fd63a5ea69287c4672128694c0363a49dd15c371e555f6bdba71829412b2108543170937aa20fbebc0ce025de16f520f6e6a7769d70b36fde21686584c91eacf4935d48f9faa6f4f565609ca94faf19a8f97a020a91f37557fd81c376f6e1cf90498ddf75124f468cf3dd79ee51ac7f296bf46866646684b1bc49dfd2c839f6573ced9c99ddd97fdfc2d9b11be9c338b32c2cefbeff97aa2a8a91faddd04371aebbbd937e7b63a5be803fdba7579640dbb1e6f060ad4227cdd440d294f30f95364a6efab1b30de5737e8c319a1d466ac70288c17319eb75d6fce2f489d1bf03abbcaf8d98121351c11f1810c4358492207b08d93d17daaba6d753e50c7e0b8027990aa431f46b7edd12e872b41555f74740867db9e7fac38e81b903a9fbdada67eb72075b23a98ad6ec8d516452ec7a512ad88720c9649b6ddf9b6a1eabfb1e6b03615f668a6fde187df67f6d56d7a890adb898ea2c2874e249dbc15a3da746db2ae8d4767d39ec73635462d8f3b79cb1fa863179fbe19a3aaff1a7df129a93a777c8a6a22d4360491d876e76ba1aa449b8b54df5d5591f69fd9fb07891f23a99ec49b67cc9af6d9739c1ab3c6dab6fdb66ddbc6db904d895e591eff2d897edd4bed6a33edfafa4a27b598beb23f6bf41ca55d5b94947f5ca4717cc43152177594366aaf0b6729aa45518c9a294526d5cdbbbbdba5be277773f6103264c8106659e6e347bbb4df07d2ae2961cc20c74ced35b1537b4fd54be0c1f520a13d6f827efcd42e350c35393e61ca222688c2ffe6a7f4244b8d31f6d8b6592e42d007aab8a2832a6bc230e101e65ca67a162ed5bfc60c18ab60d42fe786a7da0f5b0648b59f0cd56e29b618e3c76eeb6d20ef5e19637702acd0b99068f845ca06749f7f777777153b1def2c8053bbab5c5558e66a2c4fcf0b74ffdba93fa33d861042c8b1e009e2a7aa5405e58c4e4434f483751599c418231abacf1b54c56fef3e55f539e7eff4edf7593dab27706dbdf396461ab6d92ee61e9ff7b2acfbe2cbf89279a5ecbe8e3244c1dd7762a1febc4b8b23524941e1c362397c871f1f118a51ffec3f6f2db5b2b9bbf72caae930a687bf1a06bfa17f8fb8d3c35fabdff7e140fca5fa95fea2bf08e89a5271f7d1e0547702d7ef29f782e31c28cf688fb50a01ceab3a147474304cf50c5375422a18ce0b415811d5b33061bc0dc87ec531ac5739200ca76341851730d5372cf552d5ed3620d336a59a7a305e6a868155e26e158ed4fbf8f4f478de7f6a29f54ba957aadacb2f35dba43ab72ede057a611b49ed825135e342f0e99e403590e8b7bbb4634e4a592c1ccbffbe8ed42e2f49b5b91a342ac782f06fc836e4cf09f725db903176f2e343282797430d5061c75a1ede42f7c79dab7b73aaf6d8cb9afa7595922852a289da535749892adda46e41226235757b013f7b16cad4b8ec3e5abb7b4da9a649cdb86f6ffa8e0a08fa6d12f53ed82eb82faaa62e13991e569d4662b57f068d76354b4545fd726a371359345aa25293ced97d19a553b87bef1c058164450a48da3c59f3030d9b3b8c32d300cc7daa77df2635d121647508595a7906db7280ae129250e5879fd35127e8ffd73345ca8e3277df8fcec79e99fbdd17f9a7c85fa6caddf7affc8744d087dd475b0989114991cc26dfd08ff697d033a9c320feb09b3108fcd80d81f1f778cf76778fb7bab7636e3865887f8ef85d102bdbe5f0875d10f84122926d77f6fb1b168461fe74b6c7aacbac24c6c2fb1087bf74b6d31921be7c1d2e3b215672c077f942fc63a7b3bfb0f80b9b3f2471a6ee4eb2ed8ebf565156940082cb100e7f2d4c1b827efd1e465da52c6e2a771f7de661db9dc9eddebc1067ee7fcbf4401ba3a04139daa57271e768d7095cbfb9a35ddd5c1efe2c63ea47bf76f7e44e477579b4b76a78eb27a4cee559c1f6dcdd1906ffd78f8bfcc5431528c3260774b5ac503b3e6a2b5ffbff73dff1dae5b5f73bfd9a30d762c414acfa4f8316bea9c3bbb39bc58aed21c1f44c09faf5a3534b98fa3d0581e6c4d36fd1756264cda852eb2b00473bed5a25206ca8353e9fa22d602ace131058eab7666a47e8597ea8fd39aaae1528a2a83dae4e117a98ec6634ab050af7c9099e224b962c55ea47dfcdeeee6e60e837ab6a3bed0ce5c94d2df02e2f2f2f73535114036ba73d2ef4dba9fdfcd07f873503722a27e811fa799e926d77361c501f1c5ebbba56afd2608530637b0afa7935fa69f408004232747ffcb9bec2a68d116ceb2ede48810403c1698875e8c1154330e798bd38a184092655ce6f80184208b6e170fd5060b113536e888ae2d3bfd33ffb55fdcd08bd3529178b20c22441c15aca492084efee499eb40d20f7ee0c160b36e75097ca7dbd1803b82efefdb9af9d8eab1bdc7ddc26f4de5dd670767978e114356892e88187246e30b2c60c0ea480c2e8cb9b2e4d4c99618528b08010c3123e34fdf065c908143765a912050b396c9106e63be839c3c23e41834a4f01ea2a6189c20245fde8f7e040eba9540a427777b870e1ee76ee546c9207745dab011cdddd2d427b1d50aff0ac859ba669b2fb58ceda99ae5f0e41f79977d7bbdd0191380f348003c6872e427bb1036a8f886d77bc976be46d58e3bb7bb77b0384106e5b0999103925e428f1bedeb1daf33fc1c2bab3aefffe1a289e90b2648b2eb8b4102303c5d32e8d912c4825262e6898011616a29e78228978040bf1a3c432b9a4208120545578a0829cdfaba99f577d9ea8ec21a4a9eecff2ef59fa1d2c4a5cb1f98b5574d9f8ace951e335f14d217c0d160d1e39ed4f1b35635428e6c3d4b3e4253d12eb888d96a35018aafe55d68bfee21507f80805a6ace32a28346dcfe3a5942f5f7e95482a0a6c70ac177f211779ab9f4569d67db3ae9921f2b988c5da2d62a44c95b4f5c0bff1093f68dd96c75f5b103cfee626f81b3715c6607702fc1fb36acbe37f030330d669ebf12afe265590bbb1b5b91674d6ab0d786c769cee4cf00abbb93cfe90bbd1e9c4cafb024605cc44a9b17eb3aaaaffac9ad426aade1d6bafbb487bdd42b18eb550bbd6393e6a0fa9bda3a2ea2deea1da5d04d613e00d343e0f7f6d10ffd68468a8bd7e216fbd62ecba999b1f762cb63ffefdcde42f3e72ea981f710763ee465ed45e7b91b7cc61db38ab01fd66653651da834645edc19414b4df8ddab50c83cf1c47719bf682b21868df40fbe98b15c37886d1ad343024f55c23f3404a6dd91644da8aa0f59b5e8404c38bbcc88b901c0867ce8fa5cdf95f081c65d4aea8fdc91ea7fb7abc55f779cf62715414520819e745cb039fadd89743d9167ce8453dad16c70d6000306078d18b7ed171d45c8a54e1a7aaa05cbfd8396c3a824227c8d41efc6c05eaff41266e611bab8a08b517e3bc8db75e741e95a2a268ebad498c55f8dbfa58adf211f7d03fbb73a6393baacdc8060afd660d68c747cb037f2b820e20b586ca70226f1579cf4a31149bfa851082cf54f74dca9addc7faf7bc1eeea0502a8a7eb4f292cf49292f41d87a8bf2703aa29ec0f504ae9c3375078bbc05e39aa8d831943341758c655db6dd005d252c512a03ea2af960a4ce4d4c7bedeeeeeeddeeaeb66dfbddb65f7126502075e6b9a85dab5fb83aa2feab15e71d2f759c7486d2dfb88d334507c3b80b3204965a43692de2df558e7ec1fc49a4fa742dfcd9c9fec087f1bbb46a76cd47a3fa66a5030bc379ff1dfe7af1fe3c7cfc6897fcd93aff18db7b27a5d0d4af9c5773a5ea78b427838bc14d0e06e7038463074702d7c3c70f20cbd30f397682d305791bb5d78f84f27f5ca4ea3906aea15be55d4dd3344deb36b586e2d45d43553573427fe1e7f3751290da8f4213283cd546c1a976976aa19a7a8dfb4a9873ce4f711f17d5395fe34ca040af3890aaddb1ce50ff8f8ed0307e5ee9701877413e7e0019a1613cbc05b532107e86847ab77e54e1f4177f52ec62db628c11c61f1ca38ff69c999968babb7731df36d5679f96c9dd1d6e5dfa09caef31c618639c31c61414a929963fba499c6f48edee82bc2551e0d684b626edb5f3100f713b8c329b5a6acb603b55ce4082fc2561cbdb6a878f7649a2fd81bfcfa35f3c34c463939635448538c6a24177eaf2e6a856188095250e8e8a5719f02a71561ce80a3b9cd50d08a40d0f0149a9a1ab111aa6ea362d73a656234418a7a2a0fc1e25d4de7fe3765618f8aaf98bb549493472d45f38822a618dcff2178bf5f27de2a87652085b08dfa706bd05f9050d5a8fe52d1d2c100a43b5fe4afdf6fb4194e52fd5e3bce7293535722ea82a0ec2565a8c1ab9145415c7309cf5c6d19647fea65a5053ab1b31b5f1ba372c4b710cdba4cce6b2941b0c55906f328bb208061a19a58c467ae842063df82025d403540f4f47514bb64dfed66533d9ecbefb82defae89ebbebe860180a754a772c6f2d0adc1206ceaef070257ab16202153ecc92450219176a45494d408530cb11298e51c50db401fd39770059cc322a33581200a4a126ead65616e5f204005e98044085091b72b44405800a1635c8488a0160090c3180689313c506185a8a642439a1494b319668e14597211833d0c1121c213a033632ac82587ad1820daa2d4f383ac4b07569b3e2d2241584ea08251a12d3b6c30d261045a91d7ad024fb82a4b110830c12e71b52a514d8ed506a9a8faa6180562d06218c2a76cd65e6146a3307ba72c745b1a318a3cc6051cc07548f858a1f5717e89a4dcd836af48b8b18f0347a5a6b836d6010fab38f114d098ab2c886a2a27ece6244b2fbb82916bb8fcdc488b2f659719eb7fa559ca64df98d03f2f1719f39e15cd7ba7ebeaceed3b5c1310681a33389bbb4d76278cb82d09f71111bd5e6b23ccd48cbd3bf45b9325498747f698f0f529dbc64a6f258a82615eab2c99885eab76e2ad720a96661e2ea866cd7ab7eaa1a630d88d428a6ba1c50e17bbb2080c40bafa67089a44ae93cda390345abc2cf7ca0fc3b9f8aa98a0a1fce333754f8727503526f1182babbfbdf89da5fa3bb5b5e4117367d9629aa7266ecd0f86a84b062f6db26b86655bf6543a37eeba600f5e3221572930a6d68aa1f4741533fae42a67e9ca54b191f2a7cf893b2de3343830adf0708475011622afc1d3cd854f83d94ca7451e10331e342cc882342410c159144d485a848870a8df84185ab74441215323d81495a7e407dc144d5fe7eb55392d5dcd7d2049021535543cc39534b2f644f9a0d5c906f8ce698343344a86c8c1647e090b77692498149056246649ac0d0051299293174d1864c17255c3cb196565e7ac67899410a54b565099521c4138a5357c98bd30a5ea050f2624593924aa37e71618a0d47b5fe92f37b2dfbd433a79839db70562aba62a9a637e1cb48867eeb04778c203584db9f5648fff6ce09b192a37feb84f8afc70ae1f65994d98c518b33c608a716b3de5c085aa4c8fcec8bac82b69fd11edcc1c35bf0356e721a19faedc1879f195958bb77ac22555b36b537c1bae04b29a594504aa97a29a5dca48a7b999252be267fca6c8e912368d7278384767d317af09052ca9711637f201fc119e46ffe5370a07495fe724b0f552e952ae5ab7ef5ab97d23ba25acd25fae2e9cf3034867d01792bb63f5ce5f39275c597f4e533917dc11baa3c3ad20186e10401f9cb0795f229c74ede92ff8293df7cc44bed4933dd922fa1bc255f3655f95bf74d0905e52e2354d605e170145b257c5613a15ab0155536916fe34c79e12d29ff45cc5b9289bc253f7241da93bfe2b8c85bf2559cfc3984fc96cf6be44b03b069d7b76eaa7cf90cd52e7ef941dad50c5ffe7403ec4ffc4e8a3d81fe2fb544fde7a3605f392658577c081f0433aea8908538badec23a0c0876c7feecf6566c14153a013fc5adb7b42ec810180b3e73399c0f0e6fc1776e8aa1df3a55081f3e0f98e30f8f7a4b71419b7f563a23c8f7d7115fe79bd319c17ff3df7474f46fdf9c4ac7025c754ce0ba55879dd36115a703db381dd8cc80bc9535d7e3adec990b9adecadeb32c0b2ae27f65db9d55f6d9e37442ace458753afcab5f58f64274b8d309c2f9d5e374428258d1b1ea84648ff3389d0ebff64360427446c0f9d5e7c0f9d5f3afba2056b8cbb17aad0bb2fdea83a81ee787c016b6b0f90bdb7875a34f3021035ce1776061da9f70437e90a6c393d3819130b91c3b7446c0f9ec75e07cd609b19223fbd50bd1e14ffd7c9cd7b1fa179d90acd31921f5f375b8d391faa9a343cb7ef5d139ea2df7d7b88cc3e154dc7a2bc5396cd3b8854d6e61d35bde83c7dc286d086c88147fdb5e7587d03568f4783b338a6c140f6d296eab8f99e27ef868d7d66fa3e6b2e3687076328b2c75afa8ab940689ba65aa6c7563f55bd7c46fa8da704019aacde6143fc54e4d3ca93e3e47b52bf529fa829f9a9d82a0dfaa51fdc74e1bd0997563a78803e33f7682d1d1f6e2cb2f74e3384b7b717b6e62248ebbbce038a9bdf82a8e973836d35e7c8ebf757ca425654be8fb03f964a81a678c5f715362bc733af3679ddc447b5167763eda8bbfb01fdd8aaf75a1fcd45efc54c74eed695c688c5f7727617ffce34f0b789d5d17d43fc6df18e303f1e1af181fb7ec8ffca5229eb7628cbff13796bf7c3875cb5f24340e7fede856fc189d6a8c5f5cfab17d08519b181f1537a17a1aaceaa9d135d523f5ddac1a811174beaabdee342d0697713896a75f7218589eeed8aa05b0653aa15f1b19f9cb9b9e11d4fedc88627f2290b7fc27a52cd6bfe7f5f470914fd19c94b258fc17e8cadf421d4bd231ef7767e7a41344e857c73c4755e445dfec98bf66c751ba19ab0e3b2eda6e40fb53585077f724a22d6b96190f287f1cc1f22c938f47e830ba3bf59d291f507ec853259d78b729282810943fbee4cb5997ba77402a2d368a046e875166534b6da98af342cba1745b3de13cc1681c1e3d3e23d81f7f20a79d19aaa07ecdc8a4e0019f7c756353138816592c2965942cd67f8d1446c69a813563a82465cd40216b670cd56cd72643c59b8c1cd8dd5e7b3dd0a02643e5392a0f40e3000540b5fed2544014b25cb502ec580e2b374ed4386d75032e1000a880dab569330a060b56aa8081f2668c0c291dc6b840c598d8529b25a12d9b37dc917ae3ed6b67ba1eeff63700c31506e68c91f3dcddb38d490eec564f167dd2024a457b0a40fd541586094344853f5b80190dc2207955f8508b16257a003344831694ba584329556531cbbe20c1441b63b47d5103c32c0395fa920593cc8c9196748448e6b0ca1895399a9426417921ee84930c1199a28c261dc500896822a2896e6dfd264d1262c9525492124e969692aa5062c629898ba5186b8908215a8509172a51947e4999a1308e48b9f094059729b8e07285264597d8165d5ca81e11312f320c7154bff72b98937030182c26fb70d24f525b41f94bf5268da48bf4baa95fdaf814483d36f844e12a75294b5ddaa520267c8876c9bbb3d7dcc3a103faed5293767d9c541d368ea1194239552523e425f698290047315fc22124242474c44311b25015f4db251f90b360b178fdb5df251f414b7197b40e87b71a369d083ae22c48aed74eb7fc436053634da551dd9f858484b44959ce1a01e7d3e3300a46355d8ee86a73071a1985cb5f7aadc962c0cc586b584d629acd547fced2afd92ed80587bf662ff1522fcd4c9b3b96a703c182e05a87034df56ee2f001fd58c8cc8b7eb7845a8c27242424c4b1b913c20e28a65304fdcb191604a1aed2171cbc68d105c7eaf642d5ae16c07a02fefe1e9f3aab0f6ff1b7e10115e444fb27101cc1c70f5020d1b0c4cc141660b0ebf11667517bb4a81fab4dfdbc2ceae78345fd76e98afaad139bea832a820c533ce1c218324eb280710f2a4351c10663dc50f9a10b15308e6d39c2e1cb152a68760063228ca4a802091bba2001e307f2d7102741b8a0448b105634b9812d14961d68e1c20488346360fc3cfc05831d24f9b0e529872828307e1ffe1a72e4c311678cc0c2872e8280c52a5043364d50f587d704842143541950370c116feaf6c208da7da302564461e9e2ca1660ace8d2821327aad8a2264d174c40d942284b983330e7415757690b982d598078927b123364dead4320330da23ca96e2fdc91bc8b27f9432f1076ee4506a393a8844cb775450d15a219000000001315003028100e078522916034d317dd0714800b7f9c4c6e54978bd328c851188510328400420c018400310466686aa300e3d0071c02c855aeca7b2a2edec02ec4981f051184513085aa9e8d01efb9be2f2b392e6ad4f7a05b8bff73b21f122d66d15be022db975845bba9df2f8543d31b82769bc557ec98c698b014caf2d2d2852d1442fc871311057bb9654ab44ad54ee4cb9bd27198ba32d9b23088949ec5157f19ac094063f028e38f9c525c3c8187df991a27c62816b9e237c33ecf4624fda178ffbce54e10ad8cc2434b55f465c0bb0807e371bad5bf86a1af0fff74defe482e380ab90bb32b7c23308382ed3d48feb2fe4da4200873fb0714ff276d2102d3b5143a281bf0861b88e5768e16dd4e8a0e5459230b2ba6d5779cc1f7a08b9d1f110fe83e2bd2db3bf11a14325c061d208c0bb6c9b3dc847ee5899ffe46f02c98185446caae9c353545cd672bb641db912a1986c9178b9dfd0bbe271a49a0ae49614e4e627ad80220959fce9df1e8a400c60d74f49a31b80307df9164c30246d72091ee13d268cad035f8531b820ee2d0a38122941c74bb4d30701c828cee159ee6338d31371140a0e51b2c8d0fb9a88958c382b758daa960c9079bba5d389c63a34eb0961005a18087b5078cfbc4c5c5ee759e986691dcbdd07b90d0e4537f0822b5067f8537909d7c75acd5411d9cbeba26778f9af3dd8cb30b45694b0cedaa8aba837055322bab64fe44023c1c7f010cc58c52eaad751d364ec95c84fd9d542156e1f998575dedcb7aa24757ac6d75862b464909d468212478e4f1db01ea337fa9982274ff8f248d2eaf9a21b9130c9d26ab2b2797c40d7103075cf4ed00a110b756c3c375439c1bbc9ff9e75015a1e253443dc7cf9c50d15c2ae0406792231cfe8a38331fcf5df7f33e4546a62cc2213e43ca6bc1f4aac71347a9892831ceb88707cc14badc4a480669de4050e16080d5c0cd0cc206b45f0049cbdd1a629cd28e483b7f36a348ecaba2726bbf02d28739ca9ad9f77d32b77948b1f5039e187fc0fd4895251bb0646a22077b2eb78ec0c936b014fb7abfc541c5a3b85f13852ff2067770055086a48b086c404e36d16003f9e08227ee50048a0b5d0a929f4ee8229fa4917daef9699f2740f5a426ec627077e38abd4a08b92cb768994f7616e0acac06c58ff398fd61f68066ab0f6eeeb45486e517a56852dad48ad25f365af75c0dbcae8235b62b87b22da65cf20df4bf67429b6d63969d1c6e0b391e04b136e3729fbf5ca74af93ccaf6a0fb719b80bcbeb794f8baaa740ff67e7ac3e4b0c1ab2ffe2ae4a398e31ff49fce3bff7da87455d5e69fd8bdd37d3250c1d94f6e9eaa00fd8e3c0b102ef23394864660e6e52d39cd08dd9cfad5ea9e2e88d553bd2f1dd85919f4b50459765e3a78dbe09fa107234c5d7af0a1bd0b92db35ce332a916ab85ed8fabb1d99182fa71f2167e4f777904353d1609d00e190df38e8670dda94a0d5ca065ac9c711f67fa7c27fb2ea361420c1162b7ec9a9886f51e190630acd69a84334b2311b5b45bc127ef0c1682d4cd58aeb67f0fa465406a489573f00d1535ff0a12086cb02762d2758a12ab6dfe8dc1552c7629e0b58d391e05e45b6d372c0b1f20bd8431732eb0e32429c2105be5f7102e0336736d91e06ae9c870cb831904dc23c04168f32bbc61018f3412a7830059120634cf53ffcc9d332583b73fb2ce41644deec28892e9a7ded70c05f55f3cd0a53567fc7e6c4c0a184e4a9d6bd26c642bbd824404c32b2e2221b5f9256c994e258f06f313a7030730ef67817ded80c1ff79b39ea402cdd3e06a3262822487e3a86308b7a8dc1bf1544b8df2fee1b682dcc26717cd226651e9d3a4ee9b32fcbba80b4bfab27615af690b786a4eb042ebc16913137da907541fb72e18111670d2159fcd944d08dc6be8f31ba0b54c3721b8a87580a7d8df85dc0387798d3e82ff13faa7861954c92a23d60f2c80cdade3f8ce90517145b163f4db236d7b448112d945c058e485157235d41778803b21b7487ca00e3dbebdd771625ee740bbf4535aa2f9a430e02a2c47f7fcdc8257b68e0537970e72e5d2c06b90a30dd6b17a7fff5da29fc15e01cd63be96f8f230cdd232e1ed31f46933b35f798085606da7a81b5c156d478b1f9cd507ecaaa8e848bb1b660dc4b6eb07e4255e51d2b179851d0dcea104386057431002516556eb064b9741421cdade846b2326caa3f2d8ddbfb83bc9d49a75020211a852442b0a4e8993afbade94b2dfa159ecea981726b110676ab70a3a2aa47f1ea46e9a174204529237eff1a8d52a7323204357a834eadd5a522e6b2a58ad85780229d4410855581d827c338ef4112cc1372f562e96729de253daa24067c3b90f200c1698c4296be44128aac0a94f8fe091b88929002404b8e52120fe916b0a46a2c32c8fa91360481e76242cf34900f27d28edabe1ea0b48f4bc88c111fa5cad2c55e6efa112be938501544f9d6ca362ef2a8d25c2861198c8400f459548b23ada268a3b1180dcb71f12db303547b2f5247fb39e35082c2191fb19bf0aae4c0c05ed75a4763a3a4ed6764d260ac459043e82f3d386ed8a9192a016f15e679ee9b30807e365d9771531f8c46dbbf12705335aa917763412cefd4f198340537f4e4b1795aef726c4f3f33f8e7b3bca5ba55eb7055d42ce0e803489339ef98c255a3f7937026db1356a460db6363f62c3da93d439b29d15929308b913e96398d3a789da8035b28fc404ab41b85ad164b25668d63ce002fa8279c9e1c2f7a2d177026cb19a64aedb58811f788a6d46dd1aa672bf7a70e2f7ee5d170c55fdbc665842cc56f25d6ffd6b484ec73bb75af11eeb31b78190dfd613f22a902300eebac7d06e76a69607e01597bd3e9e9985b3114f94e86e3c11ac1bbb894391f8d9c078b2b69810eb8fa0b3c5223520e5336f6342dfc3b4c00b182d21e74ebf7db988bba0f61b27b978173b5c2e7ffbaba040254fec9d5f021262a9e56e9b80b20086e835c7f045957044c148868b1a17d6228193f593c3d2081e6f880756f846f64be4318b4fd4cce5522f552c4a2cb34c4d110bcf738f2aa0fc34fd1ea42deec24aae0405e115e50643fa4043d5db88735aa1ead305831bb26690dfb46c34435e7ab682e61b92827a6891402c5432704e2c46a46bcb28612e58c344a5c69a573cbde2835d3bc0fa017bbd1d9bb3b0a97e27551fbd4d43d9e3eb4eb3ec3397069fb685cddbb23e72eebaba3c6dacf54b9d2c63d7afd4917589224df0d8d34632f9cb5fd58667e93d52d6e59fc9f32654a6933a6c0f0d41f2dadc3564da5412698d4839a048078b3a263f7a47be3c4995c432726e996bd4c774da01e323e4b49ad0ce4c833562e8a072ec5c83d3fe6ab8cd4b0fecff8c0060128de8112b21292c21a3ae90610664141e2548e934c9e35211dd950e5e95dd3166a254b1ac15605b9d59fa4ac7dc72909674f6395fd8a2fd82ed74a8baadccf66b07f4f945c0cba2082481706f31a920e8c50b5507ec47191cd3bf5b2cae86b5e690e4e469827aba9db78c29b96aff49eaab93f68ddde8242e9e4c1b2fcd59d789e7f215b0b2a1b7fc19d44e2cb98d2b082145db13f147cbb6b1a36b5d3b030880a22b80525e3034a701d039088764e550b1f142cbd5a1c187e8a184e77d9fd33a9da328523cbbeb85a9bc748912a7543fb37552e89358ab20482601b938c67cf116c37ec05669a10c9034c86b265a03f84483aaa7aed3ef9a11e9ce559a16c047ef75840d06c26b07b13407e3e6f262d1678cffe0710ba454c857658aaa256a4db6b780becf402958a8a9eaf3b0ced1595a0389da12ddde03230ca0f338dbe0029660d8f114190291e491a2e8e5c196cd5c9574b85fcb1e1667d4d10a4419caf2e0e8291717e44469d2fa07f1fdb62861e50a43d350e9bcdccbc9641770f6ce25adce22c1cab9835298152c2682745002dc2441ca71351b49e0aa309652aff8b45bf9a72bee9f7e84d823ce4f246ef6a30cdb50a245210edc567971889a76aacf8ce40059d31145fccad875077087e3dbcc2af6ebc82d7a5bfc25ba64836291d39569f5ac4e62a60b26dd3b0a8c55ba544f74f7b462caf7dec5e47f73ec0ffd9dbbcb09ed95fab94cf73b9c7ef41360a407cec53fe67af0df1e652f4d790d40d48ded2ec643f7e90b7ebfddec85c12bc0f4710d2af9ef82a2616c58ddaafce06ba70db9d23e17a5b73177f0c7ca1c7b943011e45e213877e28b898dfef91f0003469ad0faf658ca77be30e08cf0c43f6c3962e49f79564eb3285f7d26628d10ea27a69845b831bd97f9d2785166b9ad592346a2b684673cd6e11457107a2c4fa2da5f2e970b675d287a86e5e191478b42f11d3ec8eb3cc1e14c36ccb197708f98aa3b093d7015869817f9945365f3fb135d692a0614e2ac4af401871250953ebcf9890bdac64eb2e62427b09fd50454466e7b7d16cc37c3c95fa169dc9544de5ae5178994c4937b0d0bcf8c09379ffe8b966b6652c22bb219a04fc6c36303341551acf6a7090a34f7f78c73892fd421462fc5442ff0933bbaeeff57f331588d0950ab68cedfd409c1e29c4c805dace0830e97dbbd681b0572cb654a3878677ec6d51fb89fad484a1552c738538f455fdabaaf1e9835c6f685beafa82f2b6ae08f1d65bfb1d5e3537b62a1444a113e904920941eb85df29a688df2d5181b827b0f4a8a3d4910d88b6ab1eaa7e548c0a2d46e993607e4c4e099dc17ada5189f3a32a725f4687fba6be8c8daa4e70093e3e4da8200b80b086e1670ca66bab2dd298e166dc2f8aeb6a06b611546d74826e5b870dec471d79ab3ed5a3c956ec79c5cc381c86e522a7a0eeea48f6475cd07f30721b8d23f9afaff070f472640788e58b75a0a67e2f8eec459c05e1c55b3d512a368eca2f4585fa03d82f2323a3414015b472766e7c7588149a60552b3223f8ff77c23092909ca81c3aa88cd58ec8f51ba1a1c8848925bba4125b9ab126a7ef9844693f48d9b3b95ff59c211f97e5f273c0f73463bd3cb09d555ed71f979987187868e60ed0fd489f7d2d4635dbf884f3d3b44fe7cbba022df213823c5b18769319d4fa0c194408d02a79ba5d3b86790d9cdc646e27bef01ca90083539427db62a050c6135c44bff42429c0542db9321f807e0482230070303f34751e6fc2737db6d24e7ac24491bf4449750e7c54187cfbaf452539c9b992604d45e8506aad1dbc0ebfef64431e5cbff446fc4b67b80187a4cf8ac133a7ad89f97eacd9ca1f3bf0c0fbef467122be27b2e658b02b9458248cba1dbadf89a4a7d0dd98060c345561433c544e8d078d5791468aa6491fb9393c40fde211bc0fe4c89584774f41d7ac05138ebea50090745053f009b078032bd86c5acae3f3ed5d162e582c7b6e65624237e52e46516326eeb0d6d0c46f8766614f2ca457d67c13d161aead9f2ee1ee0a02a10666a81683b2cdebf353d4ae0de451ea0c778398689f1ae8c4f28e3cc472a02f1ea6f10f3712913c0aea3f3847fe8b5de938c8b127f93959861ad7cdfe57ef4d569cae36868514a50f6927caf5cfd44c4180c5bbb4f1763cc00d8a8edfdd04cb80b1d51c8f4f7787f981d94853a08fb7b1ea22cdff8bd8b1c402eb0f659a22d0d0c5fb9e52f1012dee89ee872a4355361e3ee3be79bfef841d5fff482f6c5340212da85c25a9f45b0b4fa09c352bf2bf946915464e92eb601328ea59fd7c4aa6a8e6d538653d865989ff2c55d927caa242ceced07f3c0568409399daed8e7b78cfb1536c08738e93437ce630a55a295c0903feb0781d26ddaae5a32d2b13517456ad8403621f6afdf63592ef51607fa3a8e681cec88c3f6449f62741cd38577d03e4e3f6502562f787bddaa1a6547642839fa91c0092ed594d0e0fc1dc408ed8a5105a67344a819100c2c6da613cd928c1e14fbe7de62dba1180be256edc3ec1aaad0595c6bf549a188c4ad301c6def8f6b75369661fbd1e160260d3d9b0b76a997546e3811f91e3c8979223f99623734a3f2c6ebea7e03a2ebf746110d143eef616e1c28bbb08ad65058bbeab4f57c46ab017ea8a194bfa9a70fa2afd32308c2702f6c6168afd06363d9cc9eb09fa341d6c2ff2d23500dd470ac8d084eb26fcef802fe548e528250db3c98ae46a6846a5d0d5e9c0f7f4635179065f244916b0b358c098482c38a18a0fca2aa645519cda2528ba59e31421c50b95d5ed5e250cc680c91e3e81c33ab2aad72e353d34ca68f045ce5687c2ace3f20ae8459c4ba24335d457740376c63be64b96a44e1d24341455464eb0df977410eeb466f048ca03128892ab16369fd4d9de80aa5385a4aedd4a6d2590ad98d4d6324d0ba466bb4dcae409785d774e48d51f6eeec02276ca19ab982726b7d17c2894920f13a33b92100cce5e264a442ebd02038ba6730b790489257a64abd7921146ba48af33df91e35aa8c638dff03ca6ad33cf843beb0ca5139bd21692a40bb4635b0465a6e2459128af024c3eb7e8143a388d26d28179df0436e1818a4888594d6cba42c4b2a8f8f6ae94893505fc224f2b6076b1285371415b2ca9458081b9b3fcfb9dbec59690382df633c4317e471ae9fa6a41a78891e4802a3c3aba09d484e4722394a8c122c3dd7e6fd6a6e1d81a3685efebdbc40b704f1f3f11cb442a1014f1687e24dcb07dcd7a136ffe0e4955586daa496a62794a5086f679239c6485b6ab602a89df8d57994da511c7e4d96ae412ac4c3847d833d314a33bab3e2c7f97ccff4f559fb4975d1c3e2d57d4f49c98995f9e08fb5a8de21c700f66380c605d9482a0865232ed17bd2f962173bfa17247f1baa2330cad1ffc0ff6a5e5394d9b0855ba23eac8410055fe3722436a44045293e68c48276cfe5406f953ab1161bce914200fb79ec6262094ca4d932bcf89a021bc0c5a2e0d1d418f4f7e37406cfcc532b4e2a94497147884bf0a7d5b5d08daa28d18609759cfb41071c6a6e9d75448cede03412c04d732352be836ce172a69ceab8b7e8017ac2299ac90900e6ad4d652f121f852e052e149e453ea084ba6ed404a9840bdab1313b16232e6a8e40924d7f86e81d3d0261da292167c483c4a2bf26d87192abaf6320e769f26c6fc24e4fe23eb9528525cb34b324d2a9cc55b9c21f8af0a3e0e487ba262933b43f9db7dc16d3108a37ad7f0fcc610b8277f3f2a62e8e9e585114d129c46cb7925999e0b2ed75b3b41ef2b537734a303a3b89118089100ab426aab864ed974393dabd3b162f330a6633b60186541c1cb9a92603e734807b0fc0e327a2c5af44cd0065029aca4baf3920aa00e24dc4b453ce1fa882354ac478ea3c85312e7c349a9cf5863af0b54721c5e7ea79ab89de1cb6f09131171f94e0389f398b34afd4389f0a9b508ba33fe8ded57e9225c17133c1fa8867bb4d4525a47e8ed46e5a1e1f36f854d406d3d415de86101d6ce6809840c4b6d96dc49a1326e17c1dc18efa0dca1a43f50562083217394ab4f094c2525c79cda6ab3dfefc527a6c626c6df8f014d065568dfe83b297e5e0686c1842f1bfd70e152be3e7feb0ca52787eecc17fa8491cbe4605a4caf4a0cd7fefcd94bb30199d0f72d59c2a3ba8b6ae03d88027a723414e4e60fc94018a23fcd6083d50db3887a071fa7e6d095298e89902570f2c0d0b1003bb7a79ac42fc0ba999a8f2d134e65180bdafef209d371c550c0dc8ae9dffd478d6804d57f166280971d13aabd4dbc8f85e2fd7c17b1c2e1e716a1c939c175786af13eab9a97a41f7118c8441cdf57650090bee1dc67d12d695910663280ffc573daefa744c07e7567dc11452338b24da666480454ccf210de8b1ba0973134722e8598b05f25e41d311e4c8f7db049c5d73937db5035b0f45ae4f76d168a9e6ae243d10ffce67d3f64e9744dd16ba40508f8776a9ffa231399e63dc32048b4ea84fa4c54d35c8366c69b0816d80fd7fa8e48407604d2de72bc29b114184579d5926bc356d52f042c72cd750829828a16549709ac5c0c833a775d9cdf6e491dcc2ce90372b8b29d37d594d7ef2b584df6609f07cff8d977b53bb2354772136a014f40150fbec04067ef67e81e69653da182fe4247d9bd56f9280c5664e93ffe2ee3b1a040442d1cc92354bc2c10fa46af340ccefc36c06565d16633e4fd979fd45eb1bc0610eaf46a5914687f63bddbb358aa0eabd7c677b02655d7eec81a2ce3fb9814f973fb368fed44097f028f640878a9e0db39a934f1a154ee143436e7d9ed76c62571b17c01f07fcf8aa006d5f53cedcce6e0f5099c05de8446279fd4cc1f44def0ea9a35aa2c26147c0d040a4ff56129fd37f8e91cf0a9968862bc1d6909dc812987363be260f82c702c6407476cec0b6a7020abbb9d60567f86da1616dca446dda4b158a523dc1bbcbf03e2c13eab4ffd0cc280dd4a1705a7818f6e2f445b2152c6780ba130619bd5103adfdfe63a08d1e25aa174d3562ef85bc4bd64bef2c17f09d8f33c11ea8b0642c64e80f1a2f02577165362889fd1cb94a8a06851730e344cb1b3df44699c00725f057b72a7f38dafd4a91e05886c0e19af8902ab58ecb5e89f1601e5c9fc34774999b256cf50883dcbaccb6b766ebf1983ddb866472b6768c527e9b39625a98c4c32b54af38e6baae01e131cc86e08408a788236134fece7823266ac2cfb378f44c50c61b24455cde0ed60be93b90c45743e47c85320cbf7e46a213a856d733412038989f1878a9591dc19ecdb01e1760f86d68e53cc6d6d932e01965953b0f53c050fca48252eccd54d61653920842da46b4387066005386aa4249e2809dd0c5992274b00cc23edf8133f4ded981cda1a332b8efd27fe57fa2902b161ca741f5003282d2b6fa301d0a9b13cb9db400bb36248a3336fe4f156d401790cc4e2621f905257250682db8c0bfb0cabc55b804ff126e84ac79fc6a44fdd583d3d19b337fadf43a1c1d271de40051d473540c0dce4f21493889c44fbed38514697c37350951d32ed2cce493fefd460d37e063cba461e01dc1f888ff0ce5eed91382c4bf656b48548b4f159d0f97fa0a59c9de71002bd4fbfadfbdb5bacec730b23e7990ef22128b20ccec8d28195677bee3af6004a822439b99a7270d688ca1f9a786980fca33cc7e3b3ebe4fced9d1394dad608392f0542c7c8357576b7c047181cecf130eafd3ea59f5deac841e8cda749f941c5908db47d26f33ded1862e47f3c1e5e8dab055d2908094037307317ef426281b8091a68ab172c7910ba3e749f7542482550e3a305101a53740083f860a153f33e5430b0cc0efcc87c231e9aa3b4c559d3434a9df888e756d8bc1b8a946fd97fa325f87ff1bfb90c1be58984f050162470c0921f444619e0789a4034937f7e5cd18bf52f664902841271d7d16968ef6eaea4c84f5fd0204911c788c134ed995834ab46209bdb0c54c313c8c895b65b84e8dff2140a503fe030fbedb3ae9ca3d45ecea159f93434027c474692b0888eac083cf9c1572cd273c01f3158fc08cf1a600bf1c84002813e3b7203f73c0bc57757c47467ee9e9b0193e92630bfb34656dd222706cd90d97553a8646536bcc472a54fce25699ddcf1ee15fbac9037336aef950b81f7a7697b28455e05baaef007f9285c5854536933a8089a0860d4f5ffcc0013c68910203d5c3f0ba2908cf698dfc5f8a7d47b9b5d84f74137a248992ea7b3dd2d17b6663f0e2f85746cb86ae6ac56946924e014372473b82535c3c32140adcf9112cbc88c37b3d669fc39323b45e6ce76b758b76541c911b426070f475211223e3065fc20aa8bb56dfc869ef099f18b7b4f7fac5dd198051776d9982379a25a168d8c875fdcc609d5f48d340b180a377b8c20cdc3252dac7c14729f0b0f1aeccfd142e19b1dc3837dc40848b28c85deebce40df779ce14a2c3af01e187420caa1bf7cafca76f1195734fac90f7c479234699b56e2ce4b885acf25a7757f8881757f85c2ea2ac1aa543ae187c7734808fdf486ff4b8c12268284946b4153bef3fe5381b261b54d138257e823b85025fa56c1ed5ef28340a62c5aed952639651a7242247417221211074aeecb2f39610709d9708c2d1bf273d33e369053554a4199e018f3a8540829201455e58fbff5b15158af5128ea99ebda2386a590787f9ea58f5079c55d289fdb7fb58393a2080336988762a2446b4ef8ae1b21a6a2a1fd2afc79bfbf7e1d18b014ecd6a51a8fd8b609bb21d4a878b4ecbb85e36845558bcb3b2b45322d5dd77622f03d8aafb50ae0bb24f679a7ba8753b9962048562a2f873a609ee6d750519ec54d81de43e997033b7acf14aa129dcc627bbc898da5160d7bc859d8a84babe862bf8a82159dc292cfbf928371b3fad2d61260116ba27421ed3ac69f0aed3062d36442754645ae4222c24838979c6989d834c43b0725f8d3a2db09a5b7e0ce7a7718a2732806b3a7d934f9b9735a9b6e51b756d8f2355de5d857805a47377721cd6aa9209e1457d02285b9048e46a22e509737ae6e726a0cae1a00dd03820f13bb6af989f6dd6719f82f2587da13867290ce7488bf60d021cb7365f0f39076f05fd8375060043c204063c914cc4d66583165d0731cd428023a2d67b25937741f74ce0bf587418c98fad44d1b125f5792acf52b921981b1563005e8edea2ce643ead545358da33e95146cf0bee0ae33df88a3eb1f291880eef5a79c707d6f263778ea0410f3d10665ef5bfcf3490ef40bd6f5e57389389b5e903ec2e871b67f8391f6d361eab34e84d703a75867add1b36264de9f1968d31620866f8bdf4c853e70b3e502b1e4f630e4ddbe676a185884dabe5207713d3528da925d3033f18eb1d1cc7387462d18347820bbace9acd6590a92c678994e0cea88639d3831d7a8831836178cbde66507eebddc74290ff54194dbc6dfe81faea3a3ef04702e08c5cd91dbdcf14aa4c895dd1bf362c9f5636361b53b768f0044ab40b64ff21004d0f9a1dba10535c3667c7c84b75fde71248e141e47cccc2ef85799168cba302bd1d1346d43710cb84b05beb87224c4c5a97b4f501d8ef621fecb1ae2db1e3c70fb7259b47f35f102ea7006dc31f8bc87822966809463f55855d5cee1f5a8689211de695c4760effb3da7d4a8955d9ddf37e2e9b7b5531c9ce768c0672c7699f06d5e595e30e548b3d26096c252c6a60eec463bc6fc3a50e552295186ffac9a4390f1372278096bed342d72976b056e83363342955f371d56a9c9a686131189d56c872b3026c2d535a190cf27912922f8a278474b975811c7dfdd113e9946b7ca75e19a545aed1b67fb5399b1e0dc6f52e331cc40532789680a671635e3c780ea7fbe4c0f743c8bc641058d6e71fe3e7ee678e379cf3786a70798efc7fa66ff07a4a2fb09728fa628b6c9192b674234a20c0042a502c7578e514cf75ee82864ad34bf5a841cf1fc3dab3d22b88fbc8fc8eceb8db09ce97b5fa0ac100688baeaf6a686bd39e0d5c322af59820d77a0e3ffde79963854dbad4c62f45e1bd22bf686c041fa0f38014e8b3ccad48ad0b3be34c3e272262caa90b5a0d456f5b7faefd80ef8012c06355f5cc64454e834fcc56ebf4b4e77385cf1e418b2a25b3ce43a37b3bc54258fd6a8d94120c53575399247c65716f8ee3f0443ec7b3eb57a826d95aec5e5036ee123fe94dee7ddec5f079ffa7585ed613a2845d2e4e8652848b17fb0d01225030605212e03a66e21f9ee44855e212f7c4ff082fee1f14899aa1ddaf8ae9b8a06cbc817b82096096064ef19c796aea3b7bb498465f39b8fee7de9f4ba114783dfd350a956d9b9ebe38b129627558e07ad199412edd88bdbbca7ddca03ebdca59050f089d2f0912b121e691dcf2160cd26b0409301eb01e172668d4434f2be435c5bd08dc8d1cadae591c39fbb35b3437d4cc7eb12616503d59c710270569a031acc0c2865754c3ed3c72fc4e03386e11b35f489b2b0b8944aab99b81c0a27df00233cef7200c37f2db04becc673b4f9c3607d8055272854fc9b53d25e035242d00e5314e9417ffa8f24aef8fadb341d9d1d2c40607590b255024aea181f2cdefa399de00111fa5557f1a3e06c241e68d172bd7ba378a8db1200fca0f0631933f855a5f5346584e73ea7688542619f9ada515b38f8aa2204a34e380343f0afdddcff4064ebadaa788d01795f55cb9d821e56d503e6d424ab7a0e5248e0f80bd64a34d0291f446568203fe1461fce6cdecd2f41afc11475c42096aa96bc474398b42d3e1a2968dffb602fb1fbcd6ff015db9eeab71b13467efd051ff34b0bb5a82e4d07563d16d76b5a53c23ab4263727688e427e8ea520594c1f2741479b30b2de2948cca8ad0967d7f50aec9c9dd20e50b0eb52b0e4b76bfe666216b34e7849a163cdb023912cc4ae489b8ff1143ed076b5a244dba792755f737a2a087ac92143ff97dc27c9181772e5951d9849ec7107facf1bcefdd69543e123e34e0407d92a8b3e019fbbd9fd03ed7431337433459ce2647df06cdc96291c0c87fa8cb3e6d227bf2b3d543919e66fa9bbecb873319ae46676b11c4e3b88799239443990afd594249c16d09aae7b456125217546892837eae35313ba3e50721b4a6d87a4942a4908ce6fae512d96442448506ed4c28e217817948409cea3835399b94c79e2fbdc35934dea496109eb1027f09be92ba59071c64db85e206164d7e884ce742f3a4bdde65c521c10ed1b90149a0ccc46c0c8376dcd7106fef8cac2c03713333212784f318e07c4de2b4cde1405f6889d5fd81ff449e1f6a420f5d7416008fdbfe747dda0b8603c47af1714f1605c31b66c5919737878badcd12f54037cc08c64804df9cf4694347a4700e82dfc1d46eb51107218217c3db82d843a581e68a187141d205ded90d50977758c877e82307ca461ac4479faf869ef14e1c0bf9801b87f60eb023d08c96b3cd2c314630dba57ac80bddc495281bea106646b959cb26725b05a0142e9c65f165f9234fef63376efb226d22e7e4688dc47158fc985cbbc1be1c0d32da6f7f5fa212f436ba58193357e9b25e5d79765c558ccc0f8dedab19043d647958b09317365d9e66692c34abea9ab96de76e9ec6e16b9082595ee9a28153c74a7ab55c2fd5beb14310ec13c1c35da8de66975def23d584f3428c0bb8f146165de40690852895bd68c5b00d0122649dc6359982d9ecc1d26d95accba9570033c2a7c53c5f25fdc2c74c188915fbb450f0af15eb5ebb928c4f93ab22a10e755a08c54944edc17d0c7872022afff9b66c425eee1bb621ab7a753551f8ca2a3fe94a59d620ee536cf3aaf588ee92c28077d762404bea5ffee8c1ffceec0c50b1e8cb9296c205cf1293f0f1f291840f950ead1cb0c73c742c31e14d0bad98cbc1f8d72ffa2e9e700b0d473bb8c0a28d8dda3e0120d6025dd3f3355b93a773b6c69205f6ff5a151a0362a0e49193eb487f56679bb6afefebc53f8428f488d25d715fc340f33be7f4dcf521e5850849328abd125ed334142c8ac81a5693cfa039335241fad730b4e8ca13f54386cacc11437e296822ff079445b8ca7c03df50b0015e901ff1927a40f73995ed22a701137543c4ff3b12687d7396dd01f1dd21d34b6d407a8e503c3b4fd464db0dca20d2ce4b89d54fa0c719b3cbb45cfe71613cd28c9878cc016bbba63c35ff8086e6b6d7a47b9217813188e9ae2f1737c8ad33904676f5ce3c3783bea08bccaab25724d50929ef210d94af998b561d672edd93c8bf100a770baac4b316b61cad5ef8f5577eed8da01c5888ad0d09385ef0e8ab0e25bd476bf9c15a342cb4d15b9887890635bdd0ba7c5fad3fa2acd75dca6fb186541e3dd1f4d505b34ddfe598cb0bc552f326b5ff6cb42c5dfcfd5ff3dec2280ebfa8ec88b1244457e1abdf6633249eb78b50fe41e4bccca0c320b3210e264a755196c7850a9046b199ac20a1cb8b2da4f83932a99a4d735fa2c7478aa14fb5adab35eb223f98655c6bfde3d81162fe49b0502a84e211fb26428c78b85c4238a3b9b1d137b3746d8b8919a573c44f66e12c4e40bcb249c093b82f8e318abb6df231e1e363a545095ff087988736135cc196559419191da6f1e323ab5e5f25b16982d755dc691cd9d036975e3189901f0f4ec51d74ba37ab3c941001820a04ecc8e4b65569f6cd531cd5a8bcfd72ed18d10cf3a85321b7b55aa685b26d97a7847ef5ba45579d54926426f1c81b9656377bf4dc6ee1a2ccd9f4d452ea4fc4981333de3904c96bd42050dbb96b4d39c151e165bb611119098293c0d84669ba4eb45153c018929b869b05d49f8d9a424b6302763ba5f83e38670402f010b4e0809a8c512f4814f9b8156b3d689e8b98717c016cfc2ce939c6d8f47761efdf4fba3e5efae3cb1c03f5682a58c94c99943170ff333b92b5fa39545e31b0e921c53702f4441f95a02abc59f99fe81ec40278a52e2a9d588d5d781eb67df682a757e5d76b0a73750f0610e386d21ff10ffb73be6b515046346d84c11f99e41f0fe098227b28a8b0af1eca2f8920d087f9e32b5a7a626ff34551e9ba0ec16536b77dfa17546d4cafb86db6efc52c0c4e1d77a90e5788a1b44e852a76c9c52f280893add0afc5bd693c51230cd5df1ff2f368ab1212948f6e969b965d211de80a3bae34ed9597c9c407fbfd8879932d9e06b654b06a89da281e77bcd57859db6b2fffa833b9e068ea7f57dd491d60bec96aa17b1b2aac71dba2795821136d7516ab4b22b3fd81a66abd800bfcd46b5f00d15ab08c1bb3acb21eab01f680a89c3c456852b3496630f71aee88a147bd482a6fe1c796cbdc62fabfac952355b64138a228451652bb00f2bc90372b83a9130504246a68c3d0f9973d0bace935b480751c6227fd6b34bc360cde936a790eafc3a3fb69b8a7637dd325c36aeff0fc59b850745a7604370112c121b35116a502e25376150dd3305076b9b9faeffbf92d0b7959723ea86c4c0a05cc706805fcc244f4c42240bbe6553ac9d9fcb6ed7622b875e8d7814d0b6fac7ed9f8e45beb3756be51b9c4265ac8844883c59c61963ec4845100f40819a9c9e6e3efd58bd1f0385b1404cc495601fb11ad8ffc809664b98d1193112fb23380f3073966bec636cc3b921b467366c682d452565091ca0f7de74373081319f7d020043f16416e5efcc08328a8a9703c49f2ca2fb1cbbdb22bd8dbdd8aa3f6d41d95edbb2bcc9fe52fa1102915f13e002016d0cee972ee3a6737b2f2a5809182ac1309705ab3ae885733626a6a330f611850ac65b5e5a068ac19247906ccbc392a8c8cc93859c96ae5fa2b66cac7f90ebd45a98f8e655293f08619ed89b31d2bca1addbb76ef94dcb3c3e5b0b8a8882d737fd99622e17a86b9de6c1121f10dcaa5b7ef3e5651394c881ee8532132cd652572dafcf39748a8c70b586a9b5875d1c71d78bae16ad0b0e81093e1612ee68c6f9fe75f18823300c19372905694670ad7b9ac03c5a950875435afd6b438fbc254214ff53095b68ea197d272cbcbb1130398e3a7b89ddbf23c11bfe3701b712360b6ade41124133e11ff8d4b7f1e36b250a9e5d8f8d71c8ae74f36918edb7e440bc4984a4177b2650f10880a5cfaa71f41645835385ec8573ed2bdcfd1a0f5f4073565e9dc6d896ddb0a9809c6d6b6afd24d042d242b64931e84d051a43b9c61d14988e17c4a48af8f90d04568b6f0ea3acec7425c8ed16c2e72b240b503d0cec549c4e626c0a350018c0202c925797d6ef859606ba4045889a83bba2866dc8c7ee869c53130b86fb568b5435863bf720f452eb56628331a9746fce251af0e8d1a631d1a70fe24801dda17e280d5eeb9c23b128c626f05267a2fbdd15b11b1f2ac34c7495fe2e5ed2a41ea9055191010a3c6c009e4771b7cc32e38fe2859faada260525b265c55f3eb5bfb52f1c692908b675e5c94fc55fad9d8f2cf50ab45a396552fbbf569ab34cea805a571c6553735bfbce959f8ac05a373ec954d9d3bef3cb536ac0f3c52591ca5db551dcbe3b3d3fa0d76c28da8db6955796628db7d8fc3252b74d7bf1954d95c0ad77aef454cc8b56a77903c71214be64c0ebabab42a720848e8b634e11031f06657c20569eb27c34e842e223e467bb495b48486762b2211c9d5c584610d51ccdbd6c0c66561e7b1e40ec7edf85fdf304a51fe7654a80de21b1126d1161d2b46f897ac750c2e21dd4ec12ea003ed9882066d9dff3c9d12324410a920e0f6ce13849e56a9f383e5c412ec4d308dbd13149479b56ef68d91de4b25747425748efcd5b90d29c08221bf28aba0cf2ab55eb430118ac1f4f17ad4286cb28153ba60e81955350b418d01a0efd9bb85eaaac7d88f55daa120a434306a60628f982cabe2f6a30a2c5909cc35a28e2310ab784ebc5df62a0e9457c5116996a65feab935b11651a5861c3105402945b8a504029c594904e25a063eb4a1446938afd32bb292000239e0ce43607ce526e6fec3a368fcc01be74860979d4e1ae36d4a0fa7f07c46946b5d2716c10ed4c9a5c9c77b8d3051467dcfe3baa647f9be7fd985302127f45320aab64479db4d926c94b41bd5775be0704100f08c313317c52d0c40754f5f55d6bd54b149e4cad1a6329f8320ca478111c22e11209b1a39d491da663c89f5cb3d9bc7ed61ee55a2b70e578878be8484c2eedaa2332aa653cae65eb735a1d0c2b24e60de2399ae2cb3a007366ada32463ffe563c3f51de901955133bdd4ff8dfc68d2251ecf8bcbd800c4515c91239fb0a3abb599ad9a8c3430caae31ac16aa74d3263eadc4bde43d0ff1d96ec37143d90660be9eb4443a1a23981ce8ea40c9b94678bfcb56eeddd25f5a80261122824937542905fc56096254e3f7f24310c36139fcf120b87d4a8984030088a1c2530000dd84f871ea5206003e75a80424ca124dee335476a1b7b72553606311368f23265513142a1b50a3760d025b51d41dfb54de99abc12310356d7f21edc45a7576ad4ffa71261863c2851fe5a4a404c954190e76fba6d76543ae3532b107e70a61619a4279b0702e2fef2273feb0f00e013beb9d0053da6f42bd18e5dd2eff7a29b65e3a6d3a73587f62e1306d309589400b2e9dce4f83cb6cf04a087ef54a0870bfd0f86065cfe269eb60edf3fd47ea15a4cffb513eefafdb9d6b0e16d45fbdb2d34a3e8bd12dec6efaea71c868b52db196f638fb4380e62e51d267b70e9adff34328d2443f3ace957ea03322ec55ff512bdecd116f9b301e8685f8940543cf553d20a7dbbbbd13be58ad1cee8d460dcfb28e2f33d012edb7757905579eb165fa7ce1fff19f392a4befa7505a4a44b81a66b1ec6f90801e87caacd017c7808b97bb49718cdadf237d4b51070da37492a47698c0fa6e033a391208dd9d962dfb18c487e469279e6228b1150c4d72dee9557b58312683e38bc8d66ae021016b1284a161035c70b7f8945a85fa0526ea9a54ecab466bfb9be0441e82c144373d380b3a3102175c9d0fd401ea45afa454ad28ab6c4c7414e0156f6d5e964da99f66b6e90cd016246ebcdb6f90d0b47a49a7fd4696894220f5fc1f1f7150076c7c8824013646fe65d5a0424c94046dc17a37494f59190e741f58a95ff7317090e97b0cf2062a3d7f1ce60669254cc3bdd03e22e99137dd9f93f52be3e130d8604c6577268a7eb39276d74c1922f15f59c308c6af0156d4cdf64b7d360888427ab31db7cd47d939344ccc09cffff2f222359b48404fefafcf3f7c8b43fd35a24d3497ed6baed7ff173094a35bfc6d9e067dae100c1fad17db356091ce590397cbd3e9ac6a9e8f222e8b3f67aaa476a53c6e71c230137c95872e41c7117cbe8e5c12306d687cb114c3e00901fbd2c442fabc52a2757dbbf1653096ce91845f66bbff2fbace53a2d79343950ac70a2387c9563c3c2b1fd44eaa36034ec5faa963609f3de34c1893383ec39c8b611163cce599984f99caa55a897c65b1cffcc38723131550ce195fb414387efc6940fc9ff48865a8e239037aeb760c34838f3206f0e10c340d6d11d9a3dd59a3c3e249edfe4eb1e0952d2cd116724c9477803fddc7dd34a3792b0229834f190078fc17bd093c6d9374d8d977d11d1241e94580d33817f4656a01daca8f3d4496aa84c81563efbbd54d32789c102a811551c4128b26f7e1d91bcb7ead6daa31c7c019bdb4f9cb4979ffb36e58f2d4e04d5f702edfc9257e2b6d3b729d1e3ba4b30ee0d98437fdf71d741ab852bb52a58c989376576816d05e5d051467ef4dc2805af43a022e617bb9ab08b7d07e4909c059ac71f32b8a18613dfbc82143c17e0a7a368da07107dafc3e8cfe4cdc525268d49a123358b9f07853f941ae80a7c221d4b1151bdec362691e72d2369b15e5faa42436c1aa746dcd472a3f1f3808db26f07bba8189ef35135fee71208c846d38ced7f6e23365b5e5ea91b95423492292ca408c418f9a76376403beddef8984b2869f0a8381b5134985102992d301c0723ae2908069617a6ebfb3280f04e9861b1f317ed30ce7f270e3ee33134e0757149268081a6e87e4502acb5e518a6ba77406e114b36db574cfb260fd7a1e52c7327d54ce99308c8a151c33571017b4d02c4b8925b748c8a090328f6ddb303fcf1abcbb2542e6be29043f05bc22cf742385c7cf56ef38d3e3d63762bdc5860155db0b40196148c4e5901be6fcaee88c02d693eddada496a9b4711c4d768d2fb1e3220c4c05c29ca28946c34330c08222c96e45671c38d7cab9bf6d89e20712baf959ab40068753c7d2827ebfab911cf645b9f57b5db6f5908b9f5a4882f2eca5bdb8656faff80f0927ddf6013d71caae5b40e86dbd5c7ee11a0ae3aae08ea999b7021881d120f55823c8c6a6e016b4f82bcb5fd6dc8b8f13aa433633e1c10bba6aa83b3b4a70a0516c7d68624080935cf328f18e999a7b49bc44afaf53db8db4677d15488a0e2828698670b3004a636380801d49f2cbce58ffb5ebed974c82dff1371306c9669b2e48fc732a8547504e72d90db57d11d6a156701f0faf8fdb4278e544ea6e186d04883210556e93913c34a0621119a19f082a87c8229ad37620c62afc2dca12a668719b3e731c7176790154208eb3d1f4132fc196cbe6bd59473acbab281d39b0e98c14170aad879ad6ed148c77f9129d282d46b3bd0be32a34102fc1b06bbe381c551a3c7b805d800282770a3cfc2193a7a21e1e7e3e8471ad50193e32dcf08d05b2612bcb245b8010e9f1eea3853eec1eedd7c41efc7b6461ba52dd51e8837e0bd7ce9d879e945c100c6ba89a9361d65bfcaa8d771a6a245af8b49a5b797b58a2be5f401de7232af7235a290c201cef47b9c285a444f3d16fba18c389466635498bfc957ef79df63473ee312d7670f2e1384b756fc63b764ea571ca4c62d003e27d7425c02da9199b045cb09b0f69335e55e60e79c5dd24ad63a834033c3c96910f6a17f860abe15254baf93de98e18ac7a9bdf718dc7be0b3685738b1ed32782abde6f0bdfe79dcd13478d052feacf2348ebd600f5f2fa3ed2a12c427599dbffb92e5b76d3c3744844d6a229b7b45243060ba853f1f4bcf194030b9770c6097defff85c2bd0d96289e69ddfb73a6930c1c5751501d194ef99102bf2de819c2637eaf7ae07600fc6ce3204cae02d34554ad35cdcb681d79d6de7a6095c4da638325f6042357b9d98c23d771c10990e140d7d4f3a20516075663bd921509af9c00059778e2f0b4dfe606be52c9603f2d00bc7d9b3d72bdcea7982615a44829d643f0b42456b20689d2137f35bb5319ca94f85416b9dff768872a65be073245e0a46e9cfb847e7c972a0155821dac3455f2bc6e3365c4e366962cf8a5af106694b59a87904a914f7785497b61da57d6912e2637a4a08134347cd7ce187040b3c52495a5da04bfaf1b09a4985f1a309ce9aa9d31b4e9c5674188fad8e40d870ce67ac85481c462b36cb2896533b0f31d55330d889fb127c38d46aa009d5178256a3f90e45186125e5160a9a8a02a637563b34d87823afca2cf46433f740216ee29efa4b790eb39d2208924251b00287e03b4a8d55887396597e7192cd6c97674b32c0e66bd53b3bc7ed1b79510024584f3c8d6beab5caf548200b25060e4e99f5b4bd12a109a769686d419fcb33145731906c546ea6039d5694d90bfac621d4f0e4e014211e37c5f6639201ca79f49c3eb96831a823703dc30492253da8eaf6c4780392f227c229734b85dad0d5735530382950a8a9e859856385f93175a3aeed4a83404105026071aa1905f07ce0d87c05b914a1bd484abb62d0cdca880244ea9e81d86de791e0a57a6e33f459ffcd0d1657bfb79f3e0eb704a7850c466d2a74dd327f8870515e52c472f0ae2b72a2fb59e61f86f3e2a12be4fe4df4225e2f2680e2dbf76a4a5325aa27d1cc0a426377bb589b8ee4f6eddfb701bcf0e3e505d207771f23a29c6eb46342ec47c93c3c44f3fa72c0d0e7c9501d473d7377fc86ab59e17706d6eefc1d78b5c4eec44d488241e42533780e416f6a28e8c76dacf7239478a753b45d2176bc66febad3fead33fcec57b7965ee6d5e878af2d60082736aa436c9e7e98f1ebd671e33602c6eed9e8ef68b2f068dc670100a78ec8d368846d024f60d83fd9a0e48f5274434703c6595c0ab048119a780d17da7e1fe4df6b332dbef6b398ccf0721a7abf17d1ad45467cd937bd501bbecbc68c6161480f048e1e5ef0a93b37422435321da672ee281e95f45031f898eb7de6836a07565a4b9ec155cbe785e4f4ce9e8e8a52a4a11a267fad623679f01562ec4762b79d9adf85ed51d5cfd46c1cb11b6f77ea7f3c2a86248b0609981007e8d7dd1311a2e80248f2600297af666654c0d3c080e8c68057173c4212968d147b7c26f9234f55cc90777bfe824f4de24ae8b518c291e43ae3437fe9aff8ecc48d562fe2c8ecd9ec34d75f338266c25d7fd15eebc23b78967a8c5ca5e9de050cd50170d73e083ca5459e0d7c88207f27245abca87f0fca8cea2bd15902d5e6d8cb91925fa306a1632f07976a177ab54c4ea9ff15f0f5f3d2bf69edf9e48226ab92827068698b26e7064f64b4283525ae69065b6059298a19113280f5c28a38ce0b167b30d081bba97c929247de434a1dee51eb256dd8ac6ac0c9b4522979554f31ca1d2311d7f545b9e0c9c02d8784e298435bbebdebcba510ece34418512909b7ebf81b8a535f330baf47ada3406ae888b82e6009b8c3c340386edf1a30b8b45e7fb4b8034d6443e8419faff1676d05360e799d947967f44ae35c15bc54541cb67e2c6f9ca6577e5f63a743f79700e903c9433f9520092d15b27535c8b3f919f21e39cc27d8da93f963f91904757f2cfffe8503294744a9d40d396c29dfae7c1de62c9f8bc5fe098219cdca02758eb3985a4c3b7de8d0b25ffedaf89f4685bb69cc049bf9cdb8ee2b3261248fa8112c7df6216cded6b327e4b297aad65973884fc79dc6eefa8dc9331c3e3d57a0c1babaed9a39b733e0daf664f11d6cb1ab529e3cd9d280c558bef9d15674da4ca203ea3b91549cf8ec3f2f7b70433958bd9420417ed48871a00dde16d084c87122757a41f8e3d28cf42b2f96f326c3239ca6db7dc78c231425e31af0306786a3a6512a54ffa20b822ec0269b5f90043d0493eda803aff6203e476f48164126d01d0a5576af224d23432ba6e3a24652b5397da152baf5433fde694d2366bfa9ed80c03fa47f3368e254cdd79dabca02087b08afd4c618ced755272f403878e99898314e224ab0ded787af6cb6542ba12da43944ab11facd2e97602e6cbaa6f975cb223938ed736e06033cbc57527076867ce0f48a93d25ecea58df3435a40e996dd57fe3290745ae4d2ad101b9bf179a539f7a325db53a4024c9fb0697ca3c897c1472f825bab42a261b13c8fb5a4a6ed6edc80f74fe509c0b1607b74a9b771623b241a34aeab40fe0fbd963659f1d18ee07faf1a72c986b9edb8236eb05d207c59b023da2a5e6ef674762ad959240b8ba10b3e05f84750b94e5399dc96c7c297b8714380e0896c315d073dc60f6a72bafc304982fa203ecce0587817a80cd2ab95831b93a94cd40f065e8035df5637445c1ff03a3acd275f847ff41a21fac8eaa4a9601c169d57368c493370aee14b08822131dfbaaafa21182af0db85579d00cb330d6c151995e249e02dbc439c295ec41e93fb7318405e9c43e9fa431b75af6c97de240f7fc432ac6b5ec9f6d0cc92581ce87abd75e3ed0b2262e8c661eaa20eed586a837321642922ddfab866cda18ee13f3e771be98d3a577925c389da3207fa41ebcc2a3ae7a8700c26a008432f90844878e38db7e8a9da4124a2be94835e51b0f9b88d89a6f48a2a9ab7ddb5cc8fc1ec4b9921002326d77e6698b196dfd788f5d274677eb87c272ef33760e8e9b32902a47531d935be50f76acb8602d8aa996ca4078f21e4f0f810004fdeb1201993e381bf3e1cfd3950ef0abaebb4fb18aaf14de3edd59a6deb94848afbe9aec68d20c06abad331557233fa852608562a8a35caec5235cf236a02e16e1c1fd7e6a5b3d2fe5c05ad7c9a569601ba35f8c67eed788a1730d62af89e95e95d2ead7c553ab4a1a90fb583854fade21e0cb6356a8a87e274a66baee55bc014ae89e8fabd1ebd82e1ae34acd9b0a2d47f9d548c0b79102c281829855fe1b5b516731d4813885324f820f8245d511a5dbe54c6258fb1f9317e23ad6d5215e508aa9babfbbb9166a995f5e5db2675da968c91a00ab8ff823da01ad21c670d13158701b6a9bb979d25d3a531d361eea236bb96a93bb6d8aa5990d10bba0819312384f8f692e4ac308f3c4692dc08387f98ab7644f419ec0e07d62fff26c21942086c8ea141462d71a8e6f010262dd36cb80a38ec86c53b0081680245c74ebbc3641a9f0d6d226acc879ea55441c57750254cde7e720ee149ad6c40c4287397fc3f1c98c5f91d7592fe28a616501ff293106990ce0333f241670de3278d0b71a831650400ed7c7e496bbe65afca91d00750a7f87d08b82fbd0b8a2788de9ccd031c1af4a9599f255ce1a639f92f6f3e5ea4732730d7053abcab70d82ea9192d6c311e3a93ca579f81ff23b24984da8e5069fbc3a3b2817506483c0895bf6a5c66b97ec884f1344e36003b9c9b6171a59533735308d279f2fb50f49401d043b06e94eb4d9715756c7abfacfd1cfa2fc6db787a998d03e3edf704d9a8cefb02e326c681fb0571386c06527602cc3e2a854130850285e3a6ef835956cae13c571599b4c9f96014411517b6a695956f89e2916cdf70e83ae8771409be245c2c152ec5162b2a76c96e13964135f1e9b263e315d90868c4ac214e82b99c9037661bba985f459066258d8bc13a505d1c9a1a2061d55e8ba4fc17a9cfeb4c921a5ce66b87f50c1746302da782026f17c68747f998f930fdf557bfcf62becf4dfd38968668043811987eb1cf7db58206f5d2988f87969a65b1837604fb94e73dc517c68f1fd4ba0aee228a2d198efb5dbecabf32316d2acd1bba087e2316b4e9ac72364018b102785f6a956b5ce16af54d0ae03a05a43959b04f0d5afb68ef64970222049855bffa88c1d4df5bd2a4de632a91cf836e2c7294b629750c23c09ca160000f71573f613fed1f09809d9cb31623915ece66f8dff47501564082ed02c98f574ac58d5dcdc047ef17ebe18a20c7798a0e43169fb8a69eb4ac2420edbc142473b215004eb7e759dfca7d5ae311f2b2f3a49609e2603b44a4481e1191e1d01e37232b752dfffca41bf5677949cb4d77454d1c4f1ff9aca2b8564af7cc1f2f9a475b908bde95866d516b0f4508eac574e3c7f51a124118b049642b5781971e5342d885aa1bd86d53035b7a8ffd568336fb9c132dcfa1ccd34fdccbd44be91546836c5edd2f0c5705084b684f62033dc2b5301dddbf765a9f98358e454fd3aa0114435fa061fc25dc6f66fd3aafc702bf0adee08e88537bb3e0a21306af6bb7e4209a2e9a8f25d35db0293c8b05bcbb54f7914a9d2135be5967fce918acbe7ca7d93010a8c90c04493739ba57aa059160bdd4c4f55448914207c0430695739365e7b92cec439485dd3f046bcf46ae16c8c9d6598c3e10e44fc8d41459f0c3c12063db1503db1b0dc224cbc06d059fcedb53cde6d3c085a8a002255c602c6bbede8f460c0bef3da3e32f44be8a0802aa9294b80c46ac495b430bc1a56b5fec0e0438e2bfaa9a1cc2f54a0643699a7c90e4eb6223dc239f0ae7cc324009779c159ab49de28efbdcc1e3802acfa663b1425104d76a6fbe3574e05ead896263b3f85c4c4c93bceb4b5a620e80fdf2f6260a59647506d5a6000539b5bb4f3b5eba75a5382899e66aecfa60a9a16e31d422029ce29883fe26d1fc270dbe41490cb0c1f1ef0e1709136d8dfa0da6c07b8b3678270100b78b15264cd49045a656581494efb43644af6fdce68991dbd56250cf3f2f51d0248965292c8d00093a21539d42c080e53261135540fd4c1688164c86c1cf376cf191f9ec0d5e8d82bf1ddb777049b8df56e159bf05deea69cc2c9bb6934ec380ba911f91f5e5f2e60c1bae16c02d35acd9a64fe63e408d28fc0393bb4dd6f0590950eabb760d60f5d7fa8d740345abd4f6c168271a6e9e8c72287b1352ff62c9f45c6acc53658e334b29a38df292c59d7c24f82b0058422a38e7dcf5faa419c46b33504d41533dca2402ce17356836bf3ecf518612a35f7f9b6ef28e23b63f7d23001cb939bfbed99b877434878c9083082a03fdc38ab17237feaf238e20dd8aee06316e9358ccd7aeaace339771b86f2649f0226593161f4f3699a44d0dc574d74d08fd3ff80a773c84a24f83064ec3a46c75d3c903ab22bf300854d4ce1560c600040354b49085714514f63d02a080b6bd5ced5be4708dabdefd12dcddbb1a78ac16f5b5ab14e9522800cdb51ae755229f8fdd6d84e6b924a90766471a6283da5d6252ed610f9f67f88e63de23d1aa6eec3ba88b0aafd1c3095c9d278c4004183d817d5c10e177e7233777dc65ceb902059116031ec7b03e7196216b317c6ea9ecc514a455869ac0809e3d0277a2ac40b2b7d4ef168e1e3ba503b01d30d13c10dc87794353eb2362a501a6039a6760f0e4dcf0b5a69093023b4b81f9258e10057d96b4b16c40b3b5c3263c414f220fbfdb0d9e1013def248a7d689cdef00b08e7e6b824c539a88c52e48d3cb6b8b6a1090b34fb54e3c36b08addf282cb779ef19903ea948f5ce47247f3fac837676fa0071f96ddd303499901e6a2480f092069a0c055f609fd61c7b6e66216434cc02d47d4b50bfc1a16c503c409be58ae7884718692f24764e771dd70d25c219301c90be1aff0b8c32147866035452603b3985621623d9c509372c88768150bc5f0d79303f72155d9b2ab049917b37aac72e3a771cf55aea0aa7ff56b138667198a76ec200ec1ec5d39d59d1dcc5b3d6bcbce5035e58004395827549aba5c7bc466062c09a54d679ffbcc52d0bd8933c27e8cb3cf0e109e4626363a012b75d7d6e2ebf5f4ca424bf3765f7662465262c3e89856e3da0b901a192a4f14e4124ae82650fda5d378b59be88d5ce104c207c8777f4d860af14b33ec79dc8adb35514d440ce589adfc2f343d0b88464e6525b7b803ce0f67916202d4719f9c05d397d843f7cf47dbc701350e40c8c35a707559e892874f17c8e95acff3c6e6029c480dbf566709cbd00cc2c5aace9afa63dd76a876953e0a2de4e111e194f9a2c3f1b4f90d490b245d0bbf2697f4db59d056c7e6ee49775b94c2150b9a0d52f7cb5ecd1d8b341824188154970580a4358eeaca17d792b91054e3370589ee58a817218c32554f2d2068d5d1a97a7ab415470fe0c46d0b293b14601ec434a7529e4cd39caf72707d0fb291e035c09577b51b4120d967c845936cef4ff8483bca7b5b2d5ca8532fde988bab70b31e2ecf8386fdb3b0d874336e2b3888a336956a80d31354e5f21b610dd6b1844e20489ab164d35cc234510ca11f774251dee33781e80c0cc98fe059835bf7bdc249b594259a4328e375eac6f4b3696b097a7022ef2a43cd51e4de34ec5d0d0d40349af44c2f6aed0e9c6e5722bc45d20ad7aeb3e24236a43c783d655e4a6be8e5757a56f47e210c77837964e5515324eb3ae0cf380d6a7ef2b447aa3a64abe9bf10d1be50b10ef8816ed5a6888b0427989f571c8ee27b5b68b7a7ee0e9cb36a059b73ed1282e4954544ef5c183e4b984dc64dee6d0112464af2757e8a143520c483d5010e602c1dce4c14b28a14ade19ba1a9a179427a8db551612883b9b3e75b0d0102e07b5496dd59de032e8f7a826073ea83148fc320c2930054f3f355a631f26791fd1cc3c5512e199921075e885e97379b7db433bc3047cb9a43747eab2ba876afaa4aad4e101b49e50fa1f3fbd412d1945231153ce63f217ac283fbb5776dd2c336e694fc0831889e3c7afbc162dc4154969bbb0f2adf26eef28d18733944f9635fda7129ae36e4c7d45e8f23259e90746455708b780cc633abf0abda2a399b9ec1cbbbc8f37fca8a0344d3f19d808c398d65d0e76424ebfe63c268f124cc5ee1fb1b40e620a368ddc4aa39486aaca6c36290173e1fd1a303ed243f31030de95b27610a62f8bd8f2f43824159fa556e88f65345222961bfc632d9e82416080d16adfd672cea1ec926f0e38e494ead9524ed375e80968ee5420996275304dc0c9e4b4dde749be8a0406a13e735ca36b38cd44590da440c13f898e43b5e843f7c47c918bfdaa32752e7bb1d766b06e2b377b689d163f9a761ecf160091e8d7fbd71d1c408b3208be6758320341e655d1ebeba2b4322b1663074824c8cab803d049aff553be66c96c58d9b3c6f608ea7eb1a14f59d3166804c7148864215bb6f56dcf5c21d034dd6893bbf08c5fd41831b9b58793e37dafd3eb570e3520b56fb18ef1aa196c2c74558f11c3a589e6e74f90f83c3051afbed80baee98f7f54d767c93f88621c66fdb27a34a86b0f4a3a76ff82b161ffb396e942255d7c6efb44c8360a454a1bf3bc38cc741a536573d5ceaea7a2d9afc499aec799f18f1c12b6333c6be64c0463a309d7097e2915d4761ad745f923a62990f0b99b6296feff4a3f87b959717d6b89a56d51d4cc62e06858f725af780f0294c86906d0cc4ef85fabc0be3da371de86b4041c0b7351bdb534b54ce9a1cbc282488f353a3bbe956e75087b11a4606263a625b530894c911adde303f8708e84f1d1e368df4fe384296c942a72c9334e5eb01ad5460151fab82d10cd0091ee13f6d9b8661e6d98531e18288f88fedfbc7be7e5342c8fc0664480191ea842ef45689a903df8e47ac052d3e5fa905ef7d549ee5a7007e6dd7bda3c84f39ed83986c4ec710b60618a9de19341d5bffc186c280a2f5fed469e744c8344e66e7d40de79a82e1a95d2d1c4befbd42b28f45cc6d1c10f7791c26423558b5bb1506eddf285075702f00d8f5e89d44acfaf5307063bb523a60b02376583a7690bc8daf48000198f82090748d855932e09cadbaeda0de7d55f3f968860e28d46043c86acaa2a2ffad404d5b8325a988342f128b7ced59b1a2aaf1820c59d9646488f11c9f8260e59840a892399a1f2bb712b1115ad8e127f98c454bee16481b1c59ba7f06e9190d29e5a24dee89b546341a136842fecad449cb046d0474f996cc75854c6d6f9439ab88518ce339b0cfde84beeda0715c4ae663340507465aeb97b353bc5dcf80fcc34d4f5b372fc8ea776d3243f04da5c2bdf77e27fb7daa974417d5fc941f673b57ee46fe7b1fc8ebca2bf449aa0555310365e617412a2790b7a862203a4c05deb627abb8a7d818bd664216417bb2277f3ea8b30f5596523cc84cc043afa18115917860a11bf3ae53c0857bf847c2e052aa30395fb820d600db0be12dbc10b399c48f00787bc010a804dec95ecf2ea573a7dffbf64b03637304cc8874a3d0a603c8cda457723dfaa12cf25d7f377e5169b5391e4256675ebea20dbe25ed1cc26f16f23872dd20f7501321daf9f8e1cce8d4d445ede3bb24c3457adda68c1d94a2c3c487a0ec4c233dc663714d13136563cc41330d61b9c54957c5254af639ad4f7df8c4279515f3b0fe91b0ed378a0a8d2d13815236ac571500ec4f6cc35e52b9dbbbefd97165828b5f0578523b684f8850e39a0a5befc779b7f3b51c8f264b1eeddab56898f55bc804840fabb5545b8a2f0bf9da3b38d6e15bcc5d908d05c92a0d646ecc6580b9beac9cbbaa40ae743ea86894b8b34d1040193718e0479451a2a6842485ef2c770651dfa3f3929a44740677e6c4d384d322e2726fbaa1c753cbff1891a467819c5267bf759b8b6b82f4b28818f34527f4364d2c702799782a9fff9e39a106e247977fe4add25a5947b7b9b917c3cb0021f9956a14cfe4f3a1713592153efc1030f0f4a41d9a21d92726c62e2d70693b88f31e183214420cce4cb721bdd01651bf3447c8944e520750eb78e4448cd23cb820d8a5cba127f1d8a51699170d3e43afd0681f9b1fb2ad946874d58aaf981e01face2cb10ca74f6d3c865b23a95b87960d3c400c3dd1f487db142ed8ab59758f2af65f4f03c354595fe42291c607bbc74bcaf3faff632932132babf1a6582c6893bb204e2657a879687230ecf75c1e435993b33b1814905e418ec93733e9b00cd233af37b30208e6cc93942b882eb64afdbec3bd3ccf56bad2773ea7fb464ce87b587621c170c7a6b7fc2bbccd09491354103f8121370ffe48cbbe44c00153c53ca138c019b646fd26dc35a64e4fee93d0352a0d218243bae5905b197bd88b134c18a22ec767c2b632e99588799b3cc10295c628cd64700372e966a315cfba26cb94c2e32528b87500c3fd77de8020a7b4ae8ab9f0d538fac7f88bb828a4c87f5c8bb7692534f991744a4e4d926d5025ffc67a93107b0453dfec8f63f121cf0d27d481e779dcd7e02a6035f9f50cc35746f85e47eda8ce5cbd4556e2ef2329480108a0db66907be60c1b06889b4e03ee7b0556284cb0d044e21f5f21c8fc68fb03b7de6d6051221cf08137c501ac5f5d12a6084d25b006f419dd88d33104a26150bc81f3ae4ef920e07f0355103f6a870ce291aedacc4549fcf1cecd87245935bda3c09cd5e362d058cac10b5b5089ccee1cae4ff0f2eab50ff50e96dec8178dd9b6e8402c25c257b134a473eddb5f0ce86a84188dafba82a18d3b9639f398a9dcae5b14ba699d94ffa3185a0cf12a58e2937d8c810db31c4284f43c6a22e76bcfbb56597a379561c10063038d3fd7d815c0b26a0c0465084dc0c01a34590508fba9ee1d5d57c46633af9cb4c5649b1241affcbde6cede103d47fc81f3f0ef40ffd70592683250e629767c2d2bf1645652355af5fe12a7162b40a2b710eab272aa9558e72c8aed89bccb2bb3963b52d6faa8e6c31f953e105c5e31645a51b67e594a504be2a434fb8785d5e29090c92ffcc5ab14cce2828a233882a1815fde64ffb0d44a2796209186c20251c69a753fa862dbf87da60262fe547165df66f1fd90227ac35843f9e4635d6a9b6f2a8e744d63266c169a4e83799050e1e3c4a2d668dc52b893ae98f8710f8c4c9685be755f94c15c02a8911e502a584b37e2b66415d12949664ecbf307dab6cd2bdbcbc688b361702480f4136f97cff4276f5a8e0ce7bb9bd531142ff678d0795e8a2e8fed3199af45a7e0ec643c0eec6c7373115974767d5f4c3e3a6cd5331c0c74884e47faf0d31c666292a0e1d1ef8cc503876334211b854a41aa91b4a6fbab7c923dc23b8ea4dcdbbeff41419a0f1a2309feb421d0668c575683d239e0bc04784ca62cb5e55b2c851fd22e122996591bb548285cb8df75f769c6295e9bdcb92cb41188598176a3ea175f7f0854a22c146b0f15536a0fd26524c41732a1c3162df95aeb61edcae44c31d58fd7642ff27dd8d7a290af80257cf3ba3ab781c736d3f45561f4b98963a1422c2189d1d90ee8cf4c24b13a8971634b88fc71cda903a726148bfe114dc7c7e9f416046110664344bd2a80838b3a070881213b492ae557057c65f9337f053886157d08489cb1cd7ec5ced64e5e7fbf2ffb7500c27bcfe7fa312f7cdd465dff470203acec16aa61bfdc64993f1cdbe7dbd1527e0efb78837758ebd5da20a230650e12c0536236e04271bb98bba6eca4c21fd4937c0c74ccb227a67029f4849871c8444cdfaad4a938ac507041098548486b55f08ddfbe6b72b3c246003490c9bf32e3d1b3b7c8a15976cabed71184add7509d4aefafc2ea7c8a08033b93f593a0e94793d47bd6be7197726e5fb9f69da90ded177c6ac2dc9b387cb803a0fa609648de287a148f9aed8bfa7c30519780973a8411d667234c62fda1b85794ac54e60810b35228dbb76ee9e230acda0ca9dfed2a357721c9981c2c250afd117ffe2b213d1c9bd489cf73362248c64e917362c58f0916b188d38fd8d96c20113de00d207e0aa230767a5e7d482970cc2d6d966d4917f543190192b3ac6071d1f54641d61056265392c46b0920a0f777dfbd63b2027d747d3519f6eff048f686bb159f03bc55041a757fac57209e15a7036de4f881b51747a2dd9be989d97ccfbbeedc8e81beb64583dcc961eb36fbc256a6ea94405e9e100e08d2188fa5080e0ca4d7cebd86e2ac19a28d40f8b41c546e0daf7ef10ffc976defbdf7965b6e29534a016d0a920a010b2d38a5805738ee1adc3af88703b06de2f1ff9902c0607461d33b1839f4373c007c84879b7c30186f3018e5c44618767de3b8c96f14c08ddf2b37f189b68620b9d187553e48a2f281196ed84974b0ebbaaed85ddf5f16c43bbae7a1af058d2ae2df9f117d27d0b79fe7093b3872cb83dfb67c240991cb479208b9deec6077d838377ee3b8c90db76d3b2185920b4481307492cc940e121d2e5251ec1ce18aaa25c40089975a4212a929b8cb47d563450d523d4670a4b87a90c89d1e23ee73a4270b39475447d84103e5f0743d4ba800039c8dc76b2d01891d292c01892d60c0440064ce167aba9d2d748152e352d3938420a01e2524c1d5f424e18835d02ce5ad2340c862033a528485064c090674648a243b61501d99a20dfe92866a624d6a0a2e15831b2f64291ccd2795ba524a14c1cb51428b7e6e8bad859ddb2cb75bd46a2de8d0681b5735a1b590851b9db6ecebf244544555341279a21544c88213d700977bb2a8b95b88af96926217767db4dc3acc97dff5d30241b0f628fc6332a77794da910ebef473f0a5965ba2d21bb6904b3f7e901b62ef1716e44adb2f087275b33a1424b2f7f47acf5ac0b3f49b743209bdf7852865423fe6765337c4c9d597f6852a77ceefba82649308e45ef49df6e75eb69938787d8cb099648ffdf4ecbc3aed513edc3ef4359eeac7e753ca779d0de5ed9eddd4d5ef1ee5632675d3495dfd381854cd0ec15dedb3d0c7c1a06ed6887835ec43f4e5d5ac1099f6ec3d7fe8bd0f5dde6b8fbd7713d030ecbbf7ac1094da6e3e7738b6f9d737ff02eff51bfdc221542efdc9a9d0bfe134042a5788f9d96f11c3fee329e563fc6db315fbaefe0d97dd0f297f92f2a17c9c93e6df88dd9782324f3e7612fdfab1935a03b59f5fa8c25dedbbdb217bedb5bf1107b769f5e349e5fa2c76cdcb765e95e0dd73ce9e73ce39e79c7d1fc925c0e51e9613403d2c251cc7654f3b9ad12ca31f724f3b2b04f759c665da65b11cee95c39d16fbcbbb1db2c7ae1d9e6219dd6c4e6497559ea795affbfebae778aaa1df22a5947efc84c0344ae3d4b4ef89f5896643bfd89fd8d06f64724b4e87e09cfe266564417ecc6b0209413b3667df375da33feb9f19297d53cd98cc21669477ca39697f3396e28935ffee28804d23e2e43ed4dd37f3cabefbbc2ec7093dc9384f998f72f29b4cb19a4539e12d6231c6cf1da3defdf579fdb257f956f876df945b8d2715fbdd3767435e631fca4b1bb342f8774f3fa432dc249dbbd439a9e259464f2a3c74de76847df6d77f3c954add3d17a3fb2deb4addcb8eae6c9699b8bbbb3b49564fc162ab2c933d73bf655f0ed7d3368e5ed775494dc3ae8b5279699d05bae94b6b8588615ff1b1adbb3eedb32f875b6f901f12fb4f88c998ed4f768d7e1761fe33bbfce7472fb3a15fbf7e4dffab5b5e18867d0e4f7bcdb3b375a0117b8f5ecc864f37acc341379feefe693147b4f2338ecbbe1ceec675972387ed67d7e05a8818460b6076b60e1c6747f329166a9f6dd86756cb3e629f594a6963df7527f6cd1b63fc205c773fd858c6c6cc321dbdb0ec915ceef6f7f7b084dc055ceec182921e2c0cb9e0e59e2b84717bb040c5ddeef65ae87976b7102fb47b7adf707e791955368caa7b3d7d91cb49f7cb102fce7538dc461eece7cb0f7b9547f16e8796959413b75b901f29b8fe3cd188cbbf11e517c624fe85f1ca97af7f93bf590e23924b5fac10db4bb4a26bd08fe1a37fb1231bfadda2ead60f1fe54317950f4fb2ebdf3c7ab75aa8b51d696fc3f681c37300782f8717fdbb3c05a491aee1df4f391854235c457f6e5d8e7eb742f8bfbcd65980bbf2e57c977f1be690030070f0bf7e36cda80d9b7616e05ce48be47b20d7fe13eb7064eeeeeeee2fad43188d5c39faba8ff16d4ddfe5137da1e8c36ce4e1161b52161bd2151b56151bd6141b8a506c28ba2736cca1da30871b7fdba2155de3baaefeabaf2ff4de3d18f23ecc2146095e21e4f763a1901d61bffd35134f3e72f06c988388b3a1488b1f07833a0478b70f87002ff7d767df7dcc30db0bc1d9b0656701ee6eef239e9a49fd3670499ddcb40d8700b7f9da67199d73ce6845eb70b18c08806ee1c1c6f1e462e881117e50405c48a1bac1134d229381c7480b95026682165de8a0d81710d61fbd051f19d8a052f080966a0628ea0b602d8c082108b5cdab593e48830a15c453d0de2d5a048c0ccdcccddc2fe399999b99999b3b29842c8a8c07a128be5f23e48da2660444a3ae6fd4656f38d4f53592f8473c846efcd08d360c72a338c175638cb10d1ed260662e39c82fe3552a4686e64e49c4b0f8f2eebf715c273ba9fde6dcc9090a4ae87dd2886d9de4eaf36727de8736f8d2787af129dbddf32c334ccaa75876d07bef53de7bd9e148f1faa26427f2aa9e67d9c1acaf7453ec707859df4e725b96652fe70b362dabb029a49cd7bcae48a996695926ba2291f7ddfbe6ed1ec69ceac729b1ece9f6fcdd735fad2886acd771bebd7c2fe365888820eafcc241ce9dbfb5f3f811e2aa6bb88d40adc31358a66d3c03c34caebf3ef7dad3e7cea1b45691c8797e78b0b84ab128d6b39dfdaee5c486b4da90b2846c58eb0614577175e7474ce342bd5efa8d96d19bcbaadcabfcfcd8c326d90483ce134f2a360245d27c950f7fe54311cb87f543ead9704667c319b785b2d415910ad0e4acc46198f9db13fe134fb48a9e05de11102baff22a1688caaf3ca3563e202a587996ffc1624740a83ccbb358202caff28cfab1f22cb69b5959f982b0ca5764ce8f4040dc3aade323282828282848c7d49ee3297b8e278c57a22a123d3681ee9c112848d6c81b998a279c1a2a3597df59869fa8a1ffdcf9137172e6479df971677ee4f9a8629996399ea7f000bc5b88ce39e7a4945234ecf44074fb31dae40661d86eff4c031227b4db7f7da123697f6d2df49421682706deedf7cdbf8f69771f01821b2e658a596a27106adfcbb2b4618dd66df832dc84025e0f0adbcbbf38c8dd52b6b3e4da7b90baf237761dd789afbdfc98059b24120c4acdc6d6c4683663c60de34e472957eb2612c5969ca26233de740dccc6567c01cb4c1bb96018f956de685c0863eb765024c9a7b45691e85f3aebcaa055af7ad5ab5ef5aa578dd3388dd3836614fbb9f88766958ab09f570c8d24f9b4ee844fc17bb16a185b3bad1fa02059c3327d79e229084a7e54c59344c98fabe8c362994e4de7ccb035d835a2e581275080ebbf3513d48ccbc517309e38cb839c56c716aa058d70108c271e98e4bec5f507e38951a5ebeeee03b3a95c83b95c622bc2087a1d35f9de70ec79c4d368bed6239e46d38e7ca0bf3d10d96b168805528446fb6c7b20d9533b9a3f3ffe68245dd8ff0d67693728780bf786cfcfaf96515b8a240632c3c63236ae51027ab167596a51d770aba375983f3f06cbb49500c3cc9fbf4dae144fdca6510e7da278f2ac8e489adf51cad5ba8944da3f38ad8f2d07525b52afb79b13f57a51e7433793fd0d67d69d2ad854420d2bd3f9440d79a5c34d9ea241dc2f180ca10b3754aa0526544c89131565099a12787076b23354ed728f921e2021079a102535d0ac502283121236f7e8ee4ddda3bbc7cb30535e97941edd7dc65477f71863b43146ffea7577d7c13eeeee527e524a8f31d2eea77cbabe6d8cf37a4aeb8dd2dddd6346354f440533338391c43faf1899991986638c1ec1e8ec23e5d5a18cc9a2a83db350fb25b30c8f4516b71fdb22d5415ee3296ca5e2e0e4c1563cf8c11ccd9901654dfab32037856ebf96a311f15347e19385d1cae1170e15be86739b062aac37cc806effc45c079199b0a9b8fddd55dcfe6e24f87053d846c2500e915a60426e7f634ec09cd043f792971bf2ca0b6e42e386bcb211c2441b3a8c1bf6902cc3564091d48f09711396c252580a4b6138580ad3c15218cf6ad6cc1bd96a4552bf1ce226a92377a48ed4d1892746ed54958ef4018365b430ea48359ac9ba83b0d5e7d648abe209f389a4fe2aaa2fc2568f05a9babb7f6e632b89adb61bc8966c218165dc31ec624ceefc44a223b0cc1502eee28620361185ebaa11f61c03fb5ec68700fb235108b97ca407425a978f44e1c4c5566ee223518471fbb1246e3a39b283a0eb72f9c890d4ed0eb321981f27d06fb8980dc1b4a309f49d9f83af104330933981f87ce57711aaab6a6aee0d6772af8f995cf9cd001d04a970d3a844a389c083eba3181b4dc44da3fe9e3cd8ea76d4543868616319d8166aa423ff227071237bb716dc59be44e4a6b6f4487d967115a9228001ac1e5745923febbb7ebd0cae053e3d93f8df70c1b80e76713d7431dc28c4417fe64b8b54a87b80b4a8b9feac566901c525a3b3dc14baeafa7b18855c959b4655c597b8a9d9707d0d377426d7df2920af1037f1bb164efd0bd7bd0cd7592607df22440c23ff8461fa9b7224c5c66824c5d4f5ca30fd8e7d7494593aa2a1d4ca51b43e386a5a8ea9cb01a0587457c64183dcbecc43b2686e3b57de8452189bfb573f918351b2b4524a6c895371c57394d54d5ba81fa55f49e45c71c61871f8182300fee543f601632be68a00f0d1c7e1cbfee563f9d1b7f22e5f8c162f04808f5131c618678c31c6485f7b20b6cf5e03a2f157638c32c696196302e28c2d544be155cd3695138ab6cdabc5dad8d067799bec57346dda8dbef634f435fba308f63f5868b21f2b561699a9af42b3936a6d6cb4a7d7c757c6181d3bb218fa5031c69620976f447cb2da837710491a25fa2a7ab0e4c27dcbb7f2271fcba37c2399f28da4f68de4f68de485b2e9e088e8c1a3af36d4788b903e55fea6f9d4107c1f011050114400454a6b1589fe411a8b185dda08fc8bf0973f821f186563b3f22a6fc3f2dcbb1d5d76468b2f23b3232f3273f2f163547e7b1a95df7e8625eee9913a0222321112475c5bba3db08c7f7c0af069046ae8dc128183aaf2dc6b9ff27434f3a3080dcba3fc8fec57ec0f94d1ccd6221df41f45a6a5e1380b24e551fec78a8a0552643e108d72da674f93d9914cb1287624391f3735a99c1d22aa83402741a67b6740f5b305c2dffc6d47b2a5e8bf91ff8e78628fdecf1f93b0b18c7eb9be29eaa585597d23ea7ef4a97c8c6fe55bbe9174f9465274f2291f8a97b295e22966c765bfada8e4c5781688f7dd731648111aef3b3b62205cb749166b46f4d70598c52c0c5ce0b23b44bf712c9dc7792fa5c8dad8a8ac7c2739eeb29e65f98acca46c9f4804763b7457747d281acd701cb749aeb74de5b76ee5bbebca6e0413e8cbbdec70f8cb6e86bb760c892965dd2d318cdfb0e4777bee81e89ee5b99bf1de77b07c5d33a383a53d698e6646fedcc8b9a7f19ea3efbd5b9a96e79eb33f6a24d16ff920a8eb9397c693f7947ef70161f9eeb70f4811ec8170bfbdf6516ee483e8bda711bdc7bdc872245d96c6fb16fb83e53d39f281fbed69383b9298a561613b9237fcfae25df94652e51b49fb03a352ac8d0dca736f73b2c58f07117df2752a9298715076c452ef500f49616319a11ba11f1bd5f231869e9ad2f62a86a52e76d39ee55311c55514a17ce8c6b1dc449c55cd4dec55ab9a8787dd01abea7de8b7c059b0e9fad0a77c5475c16b2cb0df74703359a63d678170af71afd91103d93ecbf8a3bdea154b3fa1af6098f8dc2b86891bcaf7e0a798928e1d1af729f3b91b815c61b13636d9776fa3bdca17217ffecac7a8981ed4ce6c7624393b9276e443f6dbd364f27f7436939646fba16277581d9114b793af51fe291fb30a4746cdd0237d05cb00c513f7718b1b63a7627cff1a8983f1435feb5027d4b05749dc74f99b64dffa314a473c65af7dfc1df1b47d8cef63a274c413a37c58ad9fa08a63c6c6fb2e93b17dbe6e4552fcee6ba0488a1ffab85863af6674f46a951264ba8a1159644aecfbe597e2a9512f2f5341387c5879357a91cb87dcc2e1dbfee5e37ef4b17c8c4fe545dfe872f1fe24f42d5f751c3e46bd7c8c1a7d8c3a4949f929cc82f67fc49ff28c92df38dba33c10dca75820d9738f628114a1c91848ca6f76c48ce28ffbea65c35a9a39790c010c234b5726a049f243ed3202184662b6248aa7223fa4ac648f52c4c8ff0746a57c3682915f2cbfbd8d4a0c0c07b5afe76ee4762625088a2f66b3ed539e66fb1496dfde2d0df743e5b9596434b76f34edcfd73e088a8e28c5be4403e8ca2b9fc7107e6251d970131f49c2cf959f4ab26305181748094b506c1eb1e2e7ca7ec2c88794df9e26e537fba3c87ccdfe58f914eda7a5c99eb33f503ecbfe86fb3773f22c1f90224056ecc83fe5b9e75ee5038262473ea43cf723b734299c1d5dcf28ee517efb110dca6f8f32baec0f8c3ab13636f56dbcb7e15e7b9bd0db746fb37dc68483f2637484be1e9cd7baf2abfc1815fa18558a2489932a5d997379878508890d27c5dfb43654ec16216f18433fc89c4fed0fef470d42e757314a1f15e903817d6681a03cf6d402294283f2981d3110ec27a3be07b326d468674efe8653190e304c44897159bb21a3dc0e34297ea8c998cb27cf4fbfe4340ec6367243eaf23acf41a20fbb6685258ce99c6fbecb177ad1977dcb479fe5db7ee5d35ee5eb3ee5e39e2f0dcadff0181fa35c3e46893e46b57c8c62f918b5f2314ae56354cac7a82d269e5a2726f288a46877b89de140911f1875f2dee5e8ae5b1e0c13ffe4b3b1c97ebe0dfdd0632da8fddd8da49dc1fe07466176e48f7d10148a1db91df9301f7b9af998fd51c4ff47f6f3ddd284421f0475c38fd4938f511c781e2c83dde8bd480d6c061b5dc36f6ef401fbf945aeff512df697a5991fb23f3ccb6daf654f1ffbe99b0d07e3f788a4f8f4d33eee6b9c18bffb78dc8871307ec8ad9520d13b25fa37e67677c7c0a83df889861b41849b463bc47bfb7d84369020094575e4c2359a75e0ef8f800e375dd9f7bf0c11cb681f822fc44ddb163b1cd7d32f053744c1edb0975df6dbd5d7755d9a36e2287411aab8fe496e8683fcd7577290971052b72a9d28d584f66e59477c00904f03685294b5fd47a28ff1119b6ac8681d546e9cd735e7fc7852cdaeb1e4020cc6f7e8e41b51d59e7743565d8689ef239e501d32156e6c52c84fe81b0ce398a4b2c7f5ef214477ce6cb6d6f3c2a477774be9ed32eb2cf3ccbbbb6329ece0f9681c344ee32000d7c75b0cc3b0ebc6186d7889b2b822ec9e24d7bbbb7b773bf495524ad92db1cc0bcdc7a88391b5130824b169ece2aeebeafae79c21637257f2102ff7949373ce3931da4dbb7ef9655bc67197c3bb7f08518703bcfabbdebf0ec7fc4c7ebc655c26bb27474fbc5d9b2ea5bbf7e7b7e3e4cb777aa4868da3ddf8d7e51e2d7e70bb79d50e870c653714bac132ddd55a356eb57638e8d70e47c66d37dcd35ab59b0033b9da37b7c40b8e7047d77b7fddcedb0907e37b1da7e32045d238d80a6ac840386deae1600c82879119e2faf37bf5c4be4679a374575fd7bc6677b3bbd7a1cf5158500d1b07a75fbbdcc3c5ea326f2a5276f243d96537497abb6bffbcbbbddb5d863e158e69af011e41f4188208237cfc7093667323e47a19bfe5fd67b00ccbbb0c1938e0b072fbc3951b82b73fec44a21696950f9c91f295503e1a275fcc6723a4a387199a1d1ae87e97af87938c70d0c7f469f11737b4ae7b909b3cea442aa24d1811271289379189eb7fcdd10e1d8da794f7147be337199f1c0926f9731f66f7e4c37a372fd42ed4b07988b48e832cd305f90d93bcc69d9214a00e3e3671dd6f82825c064c6d50a11045f14000dd08d73f7425acb816d4f6c2c3a8b971538c386e42797f9ad51317d7c98e50b3578935f1e49aa63149fbb8f243ca776376877ef9d9c579908761646648a82a74db566860d0bf73a0d82b34b0a9a7a631a87d7fdaa77c9a9653b5e748cab0156e892b9cd871e70f298ffdfc86006f7b87a3571efb3c8c956fd4b657499ce49f49a1c61aeb41bd424255e94d3ca598f039a3aaaf76210ebaa71c74bfd18937da22fa861e5484bcf6c64d386eaade873c273cc74d9e8d80837e4387df300c4e55b141411ff43cfce449fc691225bc845bde2cb3bdd7b08a423614bd67c3f79b52b42b0f4ae2a768c44948f0c9d5e0414c6ee8377ee3417e63fdc683626ee8371ee4371e14fa8d07f98d07f98d07f98d078559e471d09babd94767c3f57736f089475cc1f5ee6efa459df7ea76b82cf631b6560d3da895d27f030506fdb79b554acae737d1a1d036bc5efe668be82b08cfbe286e1e951245cadff0ff7f2cc89c1836b1a0200c2b39a97f5e33622b0639f16f8236a54c37eadedddd1d7ae1e8326fa8bbd4de60187ffa44ed8b010ff08e0db049be480cee9163476ffeff675996c54c6793a094606947103466f08a9748ee18d5b05283eac80ed0919d9f234558325eee7577afee879a900f0afb11a31cec8ee607f6839a8fd9a0d60dc10b461367d4b4a248aa60fb0582d70594695113c209857072564a86a89ce049a213c2c1f9fa360affc7271426f99374c027e6957a9dbb0fbb8ab083709d65e5cb41e51e4b89be87f4aa7d9ad55e3471930cea3058a6beaf84449a0d1bc7b3a26ff334cdf33aafeb9d94e70e07ca873ebf7d711b176ad838cdd338dddd9814957bd1c7ce0711cae7e3eb9abef93ae50e6add975806e5fd8940f137c24fbdc411c0a76e82099325389a0d39094e188300049048dfe7e2727272c3d2cdb21b962e8e134d24d3bea8edd9668dbce71bd23cc6961cc494a82d962389ab1f338cf65e08a7751a873bafd65a2b0e4ead3335297e72439b52a6dcdddd1bf37797c3ef6cdab4359f54a33308cfc00558033c767466e82e3bf5e245317a93524a29cd28cd329b65f4692a956512fc66941cec2174a385165a74aa5338aa244ef0f44e23e91cffbe98f962b1583b7668512333ff0dd7b4a8e15f3be28905826d534cb04c13dc2996f14458c87f330193fca1b847ec8824efee3c52435f4d233564568cd829e1af83eb7fb514d73f267166f195a36f2a35a703753de851f70e1e374c04a10121fcd317f3b51161d1ff65593e98e52cd6674b629c6324f3b682da77047e230606d53f8cc12e1bcee0795d933a78316bc79c97f684cc913247c7670991d51095921d999323c441befacaf1418daf3951e38faed79e66978d2223e2204b893d516396ede87e6814f6da171349fed9473f1d3c82988927ecdd599d93c330fe8dd9068a24491d8c3939aeba9c76d14f6b4c0454381bd76533336594ecafef1a6e286266ef9851b2afeba2d7d5bd03f6e66924cd840b719ceb43ae7fd6651f06e0d297e1a7ad46f6bc7d3825a097da16e2200218f46704dcb04cbcfe8d049f62bae7de4707dd84fbaa47f7ede842bf3d4de8b7efdfb6efec0f20dd7bbfd951ff005204881df573d7906773f3beeba7d99e7b9aeebdef6ed4d67a0f1ff134eaf73e08ca4f9e7b9a93e7be9fe3deb33f80d40f3d87f23f801401e23df72776943da34e3e082a4339e91b6c4efaf9dd9cd37c2a902234a1af0f847bef1d48e8eb8fb2a7a91ffaee469905c2b315886a3b65774492cfae6f726ac83f44c4d3f6fe316a078fae8b1ee75952db90d2fc90691b926ebf3f04b207b0e9faee66990d190adcf59bc65a470f7b2dcb342dcb9e3b2deb9bbed13486819951cabc46616319a15128e42617c08e1117e2ae73fdddc63de7ba53713dc4ddcc2de616f38827477da904826dc3df8928d7df73565eb4aaaaebbfc2c441f79683feed3c624ed411525d5c0dfeb10996b99e1e519108a312d7df9970e7892796785a797f5fc593cafbfb3b2b9e52de99f88f7be1406e6ae2a6209669797fbf892794f7f7949b422f2252dd65c37450bb6769a2763ff29ee5553e0c72573c1bc5ca8f42cfd7fbfeb0f70e47160a8542a1ef1a34a8dda7fce6dd0f8e5a79ee8088a8951f1aa57dcbc7f2ad7c3492b657f96a246d9ff2d148d2fefa9861ae97eea9eb289fe6456d1ef1542a81e03fe62dd7572a07bd865bee1349fea150f761f44e42a193131b7237f4d4c1d07377f237fc46fd50fd5a6dc84d6e7b4d7daf9f6498feee036794687c31361c8c808e1e66e24e751419442c5ed5c128a7ec6e96f1eab106114729e3e5f446dad7d551f236838dd9464c953a1cf497344a0efa97e4356b506780e035af195419ff13932f228c4695cad14d37185302931a136034a1ada076977bc010d284aa5dee014305737e01c69d73ce39671082b4177cf123852f583e5fe8dcb0fe13cccc36fc2ebf7b8c31c6e83146f9ce1ed9dd352cd4fed85134b9c0cc3c313780d2732e10b7d89f1b28eca034dce0865e73dd6dae0b7126ae4fe838d759dd0a9b0a1e553c29a0093d4dc8b182923130a10537ecd5106e2bf1d171f7331ce1860ce4b9bbfb8d2c4ca1c4137c728acc00e52cb861e3a0e10537ec9c1ed22f032cc5d307921044e48923b2c0041528b7b9618c19b2b0398d1568b205295881088b0b17a07c05d7bf0eb9ee2f851baa24b9e1cbcb0d65a0e108054003932b5fd4440857fe3771c395122cc0d53491080d4bdceca59bbe9bfdec706436b69709460d4537899693f8c7497c2510984450a926e6c6497caf90949358647dceb0baf425fd0fe58bfec5c1fedfd200a442852207bbbb70b1c75ea2b4aeabccb0530022d4d07d5a12aca9a95181aaa606d52f3f1a4fde0202a2315b2550d4039fdbef3e6ef21c07f27cd0cd3e34a6bb76175678fc6281a470fd47948a2c4431382c0019e9c2f577a944c862a5455528c312d7bfe504842cdc70c48b1e2bba40491514210914162b902109d77fa5736a6a6a5ee0cec31457f8a20c2fb8411bc040f91143b2d854523a1cb105f0726530e0863368d8b892c390c415615012063588210a5ee4e0ca2fc57881852bff860faeec19431bae7c940e87f4294215dac901c0b0051c4e19a8a6a6c605feee3e048a2b7e300315123d56a0bca6082c7077f75087c365a842e3862f32a0f0801bd2b8f20b3be017583f5070a1f553852bbf04861c5cf95e8743c604d169c20ab040440a6358421528f9062aae9812d5d20b4d6c5c7fee082fb05e70489ed9264d2ec10b35b8fe5987c3ab70c29553b8124b4217748011810775b20f16d7ffaa91c10408f64ac985c70760728494d25f4a29a5945a198220832498a08331dca0a41bae944f434a295b35fcf0bb0b27c85c07c28107a25a29edde4289900b083fd8162d19c822abb945196610817071a182275c453485cf14ac295a52c4051437684983a013841d27f10d69e5a20a19fc6067b5e3e35fe47c51a3b1ae9a79a19e10d19e90844c0d955b655fa89b120d0ab5458b2964e18b26597043aacecb3d5a10224a43501a74e4e59e340c81620b24977bb6a0e2861acfed9f71b9678b1b4d757b84bdbcd88fb0908ac0fabc0a63282ba8c4a7936cf5b08a27e67a753838e36027a1e262491cecc77cb095830d0228ee7c1e50b8b8f3fd195bc55306b4e25cb0f9cdd19c832e99b86c5de136c45823ec39289eb02b98d40143bab1eeee66b1286d1cb4d8442237b90064bcc4380d2aa25054510c518f380736c9aebb36a4e11f39fab5ccb22c13957a5822b2a20024134ce492202924fe34d1d1d121c2e9e8e4607622a771e44d3c8958da67dbfbcb9a78e2640e0eb77ddc8c5981752171dd5c37d1a5d05152b50f63222b76c6ba6e9cebcf386a9d66310bd6c56218bf61645d174f1859174fa4178b3559eef5a5dcab9bbf719ce645c5ae8fe6f58da6536ab925622be67a773e748ece1105fd69593157cca4ef7f4596eb44168b615cea4492ff65e4525d3c0ebac4300c63b1300c9c81925a895ec78c0f1b9a1e380c163311e910758cd1f36fa2228ca0b77febeeeeeeeeeebe444574d7087a737428df5f09e845b1321c8c718697702b7638e6a37c7e312ca319a5dab6755cc7719e488748879bf8a2acb08c7e7b420d797552435ec76d5a46b1794996f7b77123022def2212b9b88844cf9d8b8be8452b1d2e2e5fcb27190674704689468c8d1b11d0d1c38c83343b34c023881e431021f28a136b70ba779c9c9592212a277892e850d1e1e034abd266c593e3380eab43efdf59f009014cf2677577b3ba50b52faadfb0595b17eaf4e1208b653ad7019f1887652acbb057c11e047629aeffc9c723921ccb41c59e2349e278cb73f0edafef282c43ffa47bc71119a91a45a24e5b7216ab08799bc53226ce4dddc7d8e22563f47c18c104c3f428c53868832ac19ad493c7ba9913fba351f54bf1d4381e636d58024b225fe224779ce88e53ab48c4e1e04ceb396b0d35f49ba0ebf59fba09739bee93ec20ebbfcd5043c7d9dc14665d97a3bb215bc2899e0d29e5ecd66d279cf645bd6ed8ac96dd7dde0d79ef7538bc6e769e8775b259468f7a5de7795df7dc791d0e8ee775dcf6810e961ca41163e3868311d051e3398b1447a0df83886e2386e866a63d2825c0755124c97889e2c9872cbe4580191cfcdbf78021010bc1226053e41836d04fc68bdea086a552a954e21ee00c8629d1e81d0f429d7ed1faf9018a3871489398f222de442782a2cdcf4f8dd708a9e9c01ee269e557acd7b08c47394427671e11d29b42372ef44ff3fc7801e443742e3543cc894af0c96b98e42c23af6bef3f5be682eb3fbe029ac4f51faea64e1bf2ea7a0d8dd67f7e76c49323f158ac10abb24e58282c1556645d2cc9e2585e1349ddbd8aadb6a6a666daeef31f247e8a448ee0938381ab913535353f353f35a4cd86dfa7d9d0c525b33f5ef3a3e3a01296cf4f187d661c9c73cef93338b8860058877e7f01b08e1e5e06016e7f488006f0023098eb3f3f183657be92935a29beb2824b8aabaf8b2fbebe0efba2b2bbfbed705c3de79c74ce1948f089aaa85ab94900318c9824fe5cff8824b66293e81397944a254e2ba1c49f783af9564d6443c592a834a828281663c6a41924d094403e15e5c3f814bb302a6c19576299ebba782e1ecd8b7addb014134f715552c272b07d1c8caa0e4b2596a1e126eeb7185ba5594a1429965e3c51a8a3f9db2dc1f59d22326489abe2194d4b2351297f724b1045ca770ac99025a28ad25ae3cf4e66c130397288d4f1c15132155563a821d35805c33810f7294f792adb645439503c45958aa3040a492009145592b331c84167ee19a5f2ce2819943f79efa8040203736fed4ee6ad0657b2e4469548256a1b55548813ee57fbeda4c3a1f5a512c82550ca87d2239e4eece8513172f43e0e06f50a75387a0872b9febcae87205c7f2f97ae569a5ddda88a2a704689468c8dcb27e43166107756defbca2728da28014af21306cb5badb8ae1c0b3e897c0b96a925306481a56acccbd737bce520939cad0bb56dd829db3f0ede54efbdd576cd4b6ede6fef61de292672e4bcba3b1cde77dd0ae7fa773e9dedd49216e7b9af22df6d888e2769f7f124b78c5ee738385d50c36e79b7f7add9e1c85a6e62e7e86d7fc3a946a9b66939ba2f426e1afde87d7d376cc59272e5ab246e9a8e03dbbefd0a26f9af18068c1ac6dc2d6a8c0feb8bed56b7be78b52faa944e78fdf16de1545fb556ab5514f9c8f1215d4c090c5f34fa90863ee424271f83f2312931b71549de621995a7231b521b56171b5691c886a26fb1e1832c36045ba51595cf5743fc14856cc127bf2205e5a4156a75ad556bd55ab556ad556b955dcfc61b07ddb3bc52a2cbd117dbb8bfe1ccdc795e28e479cf5d28b45a85429261c019251a31361cbca1a3879d188e8312dbb66ddbe64e3197db0e8e02b39815a364d9d19bdfd7b28cbf01b6f7ff2c004c003661bf6d36a441318f9e1684db368ea31dc771dcc7926140869951ea8161666872342aae14a798b5f794e3b8ca93b813cec384ef3812cf7122d79fb5542ab22a8dac4ee6c4134720998a12279eb8973c9c92ebac2b7d962059a9be558d62c516f7ffb10a96d1de7dc56299ae7feb8e0439f876150ce39f836164b34b8fe2e82f54c6699bae8940f1d4aa260ef66f48561d0ed6c212ee123765afd588aace3eedf3ee36a39cd16b55b7c3e6ec318ced8b4d1cf4df2e2efbb4efe572177444d5be0879c308c4711d8ef97ebdec7208d92ab77b5fd73c96c4fbfe29f630c93faa58aaa8d2bca8a11b4615d6e198bf3165a6d2a3df8d719a1735de30b2a250c356859e0252ddc88a247f16cb8134969b7d293776da37d27ee5aadcec1b69cfddd0dd9ae32cb7447d563c71360245927f64b1228b65dcbb1cf1fa8a0c35fc1497fd8d40118865b4f797aaec4b45a05404f2f65624b9165b1e59dd0e7e996164f61c64d3b46dd3b4e76edb3ce5a96d63c930e08c928334626c5c29169e1cd661d6d96131a1c287c8ca9738cf7421ddaa78e2a862d92dbbfe1dba955fb1ad6ad5d685ca3a41e01596f11e96a95774451553542e5239a866447c8b81fda0aabc6b715ecff2da5f13fb8c88774eeb3a33a82acfe3a6761d27b243841b71150f99f9de935d14ed8b3a9f0712766ff68de6d33b2f22d3b60a89efb88e4ab6ca7522d5a9d7eddf218a27b77192ff65c318912849f6212f6126aa56d9b05691e8dfabb96aba1ad76198937bd13d7c7229361b3293254b946456d52a9d56b94eab5ca755aed32ad76995ebf84f6422e2c4948331856118e63aae83613928ae92041b61187bff749346d246bcbb636a8cf9e798ce670cfb948bfd460363961f4aec239b628c325e3b628755c127f6aee7406d28c262dac827bad594d1f50f4016041eac799a87593b626664e496e89eeb575c7f0c0b1ecc8695d2b0461b5e14c328b594f2f0502a418699514a795c683ec5be3be2892af1d1715d40313d76c84b036eba9e87890572a186ccca1163dba24a27b869ceeb7df895ffa2a486a29ad9930cd3a7a5a5a585c10b08974eec82c12b2792fc5b3eb61c6cf9fad22fd4d077ae1c96095dff4b0abe7ce2c98565b8e75e555c41b8431c7443bd5aec95e3a04be83b2e4c383827c52886691ab771dbd6795e0dd5506843f9f8822a292a2929b1b5837ae1b8a9e3f5d86af9fcc62ed8c41c4f1ab7dcf431e8efa1165e391ad842dae687113e7c88207a38e82757ce8e6a6bf9f85e392d9f0672ae21974e8ba5a1e2e2f115c9d12fd41dd4f0c261c24d38f1e48f11a92d57ce0eb744fd16cbe0c4b872c2d8bae2167cba74c024ff52ebca89ad2b27b6ae9cd8ba725a2bf6627564e2a0c79fd8ba585039925a3e66c1322cb10a3e7592c8c3327c1d8899442c7849bc22f65c224ef20f1d897b127725d7912c89e1f20d345a79d6d9c9d1c1c9f9548df17dcc302bf2ba72ae9c8d7aa18657ce75ffebca71d34accb5e45272fd4a72fd42722f23171536e48bc875a095285cfefa5a5c9ee55b5a5a5a5a5abe2504afcbfbc3f0e9e21937adbc3f8d9b54de7f879b52de03a8aba8f4cc1656452c11cd0800000000f314002030100c87c462c180401275c50714000d7cb04c6a4a9b0ad42888619442c81862880102464000004666081a008dcc8a41a3bca952f694699c319da2702d7b886363474789ea5c6ff3cdb9d275c88ad0e666c38f28bfe7370ba34864b66ccf23d21e22f1b2e39e3a2c48b3bc9cf13d198dc0aa8fe3e49c91769e085a500bcf2035e7065ffec413009d0f9d87b6d3460a30c92de368de5ff7527863b94fe226454acdfcaa077ed660017df44ba9aaa9859dbe88b8ed49c1228d641d0ec1ec994e2ad641eff81db632c095fd5e69027f52351cbb7a75078eedcb589bfbcbaa1c293a0fc8f68804d31a9cf8925b6282b1807e7088c44171f41605130522ad2ea7ad5e85c3d6ede2a8054792bf1163b31035ae48b1c5ddf01c14f4a5262890b6e31de0b579ac2ecd65de4abccafd97e015ad586a762a278497df65c6716498085c965a578d2f48971560f480ecdd6a3536281054874895de491cf5cc5ef806cae48190ebb20bfafc12e9a14a2a0114c0ecdccf5345362c1fec453061c79aa79a6461dc554fc8c106882f5c18a67b6963c2af64f61454dec40c5f6ca47470bbb7979f06aa6fed566d3e5d68dd53dd3eb5feab7a89eed8352dc41907e59e21a7b72e81ab441e55861ee30cc8b2e603762f4f2b5c3efb8ee7b8503f8c14a9a0e656556c6e9572ef3e0e1290084f36e96a927fddb7a636c816889563a3a4465ee0244ac36bf6ffe513d5e0246a45d3aa1bc4892bc2142434ae64b93e52ad7c51c4b776fe636ee707bc37c60ef24c2982f1e4e995cae65b23d5c972dd7f68b2107a729cee898b061eb471467bdebad21e95211632452e96ccf0e0b6d513441521c0752602ba16ee4ee6e117b759a04d238793bbfc7580e7b680c4f22e80b9a6c9840077eff0edd8e785333ae00f31e8c2abfe9aa7e07dc7dd8df9fadcef6083075d2e079fbb4601ad776fdf35a45af1cff52705d1d9b572b6dd0bf2501a83f01a474fe130b7b7904016e1bc6db22b70229691af6462ffcbeb979fdfabd80091608461d00c1816122ed6b419b7074c7dc018d7c6dd456da1a4844311a66537da1ddd6c4ea4fcc49838442cc39f1ad8554cdf94fd61945e218cb32c3689983a4bcbc1ad982d0f6e636ed97470ecc724113ad7a7ddd1711e41b71f7b225bafad291df03c626eb8451ce6697ff41a5361a82123dd27a9045f76820b7929c383a10fbcde5952001db237565a7afb136fbbc11bed5b44ed0beaad0d01a1771a4bb99167305cd3648f11ceb544c3858b0a04c9082fc5071a0f33f98ac537c59111d82c1c451609f933d0958fef9d04beac7a414d6e696f3775861954a1bfa47cd5e6ea8fada34a325a880e19d58ab5a1cf8c8fda03c724055019b472c94964b08dbce62443b1df94ed99b27dc00ea699764c73d3d413ec18e2aa37067a956905ab4ef55fbe90411bd08fb355f7832e635cf15778b5dc664324b1d26af79a8a4fbfff9ef61511a99967444e5f4310f496bfe13f830f2fd9262157a8c72ed4d86b4f1c37c3d6147007f8064c8eea2b79357962f0a46a8453b3b44a26393dd639236d3813d48c6f9feb39ce8d43088f3623554ab1960223762e66eaf795abecf499b0fd8197eb4054ce00e4c4045c303dc45d227182326f814af183a4375e86bf42e7bce8092b2d0543703adfe543d4cf75c13aa9e662be0b8415370246ef0317fe9cec5b27913673614921108b53cd3cbabb9bc060db8d2dd4224ddcd909e265bfcf5bafb5d133a3994e987cebebea68527dc12f091163ec99f73c44ea22e687a21ad006a8cc60727487fdbae6d33da205894e188ac9dfc2d587e13e3f1a411731d3f5ebd0c8e7c8b513685ae8822abb318b3df6527a56339c238a5710263a1684d299a1fc759e0c3dceaf8548802e45d72c77a8aaccc22419aa5444a7600466010a446fd3cc76b86118d208d9cc98dd30de458bf3de6237ea5b202f36899fd66e8ca108ea844d5d6b02e0053b76208fc34d9276943896d2bb558add9a7729eb00c5512dc4566c20973733e637de848df3d3358d215bf4e01ff11d73220fa030a8d00b89a84bf0fb1c3b750971eee3c41084d792fc264a6a4353cf0c4c49500c827f3e52317fd279e41dad6dbae58bb5b6219b0b109982bb0a160615e3da97bb761d79a489c7dbb73957b613e857c5388b0cbb6e2a3ede115d2e12795c903d52710594698c5c773c36b0909862f0684cab5d99b667ad71f7a9b1144ffd728ed2d1c70f669c11e3b54edebfc0a1944789280672defa397a2770a808cdea2258eb456127e81cdb9399b9b176a20b8458318731828d0faf70aa0032f7228e6398a047bcea0f3b4a02539bc8eadde927add5c70872db0731fe3eecc9d0e670c75cdc1d05117d13084b441f60c4b26e1ff5f7a23805e523644ca40f04b7b498557ee25aa17c757fac0bd86d15da217e1af2670c6d1d804302d06fc371548e8e7f09b83522e1a6ec1e0a7a8208535605d1c65ce4fa294c057444bac5455ec205d5dd2723ad3ab28af015a5d14d09460c2c12b3ab4658e0b5a1b6b61cd7bbedf4374996e6024623bec7097a25eaf395beaad4d78cd9fd1585d830597d513844bc324faafbeff3c6af9a887af261119223c67fe6f56b3e6986066595142f68985a8fc694d2c4cc8ec49579e86bc1485157fbc53930412e918c61a020ff5476026a93b6a249e393b379aede3fac2e6ebc4f87258aaf9a7b6864519cb79654a290754be4032440155d19c00cffc44811e9c3d24244db02f3f6f86f95579a9619ce816083dea7c6915e2ef357ada24dd4c741fc19e1eea6525ed4300edf4e8b3dbfa0a82501771a6c19c339d296138c97bbf98368b0cb2f20d6f2e91974006c2a84ee859ffb39213975a36303adce5fc51989fe1ecf8d75966eb5ee17774fa775e7f30572639464d3f955c05ab4550ca9f3ff2b25496dffea3c1be8c4c473ba59e78455ccc2c166b626ff53291430811fbc1f6c17f36179e622dca1984ed10251eb3e54103d521d02d08072076e76ae4d233c4485d326669861c995d9cd18a55b43a589b91fb603307afc118bab44fa3e31da26f49a2e7b88c3447617a6bb2d9689ac334b80c5e6aed783629e21019b0bce4e54f20cf3c6d188a7c342a3a848d8dcb8d1a72ed9d8dbbcf79fe23c3bca7908315b9c73f51e033776f418487eff65625e9c9c0f2f415102d881ee95ac4f23b96bbbf97e2b4d520962f6db02c3f9ed7c94b6205fd0071ccb40d1c46e351776d8756cbe558e882b8d22dbf583bd8c3588f9d96a449d1fbf1951a52c570188a918775da7dcf8d532b0ab60e4e7342856395ac1f2116b9f6bb492afdd4b7ac0328d01d1e8eacef6987250ce302177c63ba51fb7c81ae0d692061d661626feb10f9857ac62a0f7d235126c6362392551213b76b69470a88dfb741df2b8ccca472bb05628b794c11305924be24741c2e0b33d851c6ea3f811499c765cfe1fbca9a16ad20b07275fe83176d7fd581747138785cc2b4190815be8e400c301af5c1c0c360e22d5dd1fda12c54dd95de1dfbce819b158172d73b0031b46a74d82f5613339e1c534d7a5a0877868b08a0eff6a2981f9d8147b40c0c049f1125c6e6a65ab26f2354f583b3c6927958ea3a3fbbd4246ab414bbf9b2a7dcc2d3e577b12d64ac6c70551c0155a5e5d8fbc00294b7f6e7eb6281b90f884514492a136180c710faec8a8f1bdbb233c731385fd83e0166f9e816837037c69153e11e0a0c8897f539233668e954d68e3ae10fbe5629f6f97984fa816076c58a4967f2a15e299df3474df6017141c54ea9a290642f4983cbd92a2aa75600b66506b660f91b8947e22ab5d511f13404437c6804e48a0dd092c1ddbe3ab8aad073ff0226218d42bf4e8ce03bb73053a47f1e416f9e62386d32b2ec01321913de236a5a8ab5a98674e4746172219d6bceb0369eed671ba812e283f8bcdc09b9e2fbe093c7438aefb91909e03a6ead2086cf20f355915d481548755e95faec062b9d25fb9c0cb656e72f5f20467e2c9ad809085bdb2eb7919d5c0e589a4fa9764987b6afd72bddd64d7a53fe1c855178396ba52f6862014793cf90b0e4df2a6ea706c63a31b22f8c645eb36cfc428972db03d239fba54bd166a1b8768864778bfecca7c315c76704d6c8d0cd72d4f81a8c34530df783cf05d0de3ed6b33a4ad0e3f6262fca1d57db7eebdb35f0e0b4aedb7fb26ece20783d96d6350dc5a86e5e8dd5e88db33c9595804696a2beeebde55ec6c3a7e0e8c281778cc613c5a07b2b30a522e379b38c5d0bd4afa7c92ef63b99604729bc6a7e7914f6a916f96e19fe3d710f92efd8c61d1d3074dc2e0d8a2b60e710dd2f75e52f8a2c2070604a0a1f0048d04f0eff2343522a771577bed36db058395a1344d56eccd37af2ef84da48c59043c4e347b3cba95bd4a0b89d8c5f9b4b0759195d727fd8dc41c64ed6f2edf6227ee6e312a2f96d3c702178e51f45edcc6db6ae70e6a69745d97343eef7673724cfd043423a1ccb73c666615d4f7e8a8f1d51fb3288ae749fad71241bec10d51c5069f8822b9cace8a2ee8d43283df4a958e7a60769f7f4eef5934f30c5806e202cb5b287f6544b1ae11a6bbfc6dc1ca0e1215190592a7ba2f81c754ab8280a6e428f3400e40a0cca9a6cf206056647f5a379b8b45e877830635231cde3e4b7b35c7b980e1a79621438ad2c642bf5d81a15a085387998f3b22c6914d3ea33204c1869d2f0850d1d1197dc2e0b46683f57a71e2e62a183c57ea600215c6648d115382952b215815fa573a44ac88466faf7526933908c12342dce122224c89e75b84f1be0cedde068b9f5096429d6e7103377b608f0d3b6516b7661a913f45c0e2778281372567a7fa122402960a6735f8f27ea13b9362c25e4dda0cde01365ff0138eb16fccfa1c119759ce2dcb0e534a3bc391b245d60a9e421a8630726389c292252470ca3e5be3522d3c8f1a952dee187caca8eba4615e809ed255eba72f8d94aaece9dc10d6c58ddddb74b8c2a13218391bf8c0374a98a8bfc90e078fcb679e4323a6ce224f32680c5ab34e36b14b886366285ec8f742e4cf4c884979f7de8b46ce8b08bc6208ad1389143a087a5af34d3844576bc2ce7c086c674e7073b84f3550bf67882c4e69a99993fd568c35bcd578a3a2e844f0eede428b0e8ef706b88dd9c1ed02a3957af9720fa7c5e57f984aa91b8cb16d3cfaadd0ee133fafb4c13afcc8a50e70e99cddbe236d36e32213c53eee5f1364932295173c9d8bcf6ea794faeeb9a4d34e3f08fd9a62fbd6ca7e1b9caffae5e960bd855abe3907d8802779d23eae9dd0700f834c571ac36167c8947396c2b5b01d9c0ce33727d52aa16f0a9a51abe42aacf04c3063fee9a6aae32c6da021cdea5270527ed95a40ad31bb505f354a74e2cdd871cc00ecf454586a9d9cd6399a64bccfcfd9cf9cfd2aa3f51b1240befc002f18b4e233487295fb05c82395f4a37f118b7de98247cd9fb9adb2f30ed4cb220f82143b8cf16966d1135dc396a0c4b90aebbdab0fd06d5e4d6833094ab305e22b8123123a8158a87f8314b88a99f45b99652bb2f23761bc4fd822211f9978b1d54268f7cf104f57770666017f84267bd5f8ec1854b747d845736b85d6ee67110297461d93cfea7f67a54d44df040a909369ecde1c5033dfc5d08ef502e81d2bd3f85cce244342be7f1426ba07697b3240227e467d90ca77e36a430c9409242c33e6b28013c67fd364c6691494ada0c5dc045844c0afac0e9881b74a49bb50abb9af407417361dfc4eb849743738b7b6cd193637bb641c116fc1a7684e34abb171d1fbf144440042cd83a27c17f60a62fdccd63f824e972332f6e41fcc37d30c5d0608fa790f2d98b86771f6f281726fe8a18657b1fb79106c2921af34967dc1fc9c43f1472ac3bfe457b8690b56c1d35c549ec5f2407e2245b03a8a1ed3e94b2441329c756d6578cfb016c334e8946c9c9bf42fc6968a68c074da44be587caebb1962353cac9dd8193224469b03502e20797fd9b138e9c7de7125a028f93e5954c085510ab4627813dbb0a1bc004cfefca5147224fd9bda34b56b6d49140821a8f7b667561d028208e7eb1e077beeb05f308fa4eeb6c6d46dbf7f4b2cbd9dcfb89d896f8e1d13ad1027f2c4b80fdcb5e4565ffcfa33b2dd6813ef1a64c59e737d3c4155bb6ca735139b26a577f80c1ed650bc88850b06b9cfc2253f7b99de25278e0a7f21d5cb998a9b386816c3d934bc93f044756fd883a70ed6809b344d4f926501449d13a09220b49b12d93788c0f485763bef47a138b84bc1e0dfadee8e969340dd8147a493034a178e4bdc83246e74802750017cae38a0e77fb2f4cfe12d80e4c2927c6c04b78585a719503a6a691c0aa694bdc993928a8ddac796f12d2a42400f9388147e8cb2221d2896aa9253fc69323f2462d928c6789107f9fa57a9bfd1472fdc747952ad8afb8d2a7cf7fa8f31343ffee74ab94d5b644551b847da1c72005e0bf005392585d66833bae7dd956a8aafb85eaca206380e78589932eae4c639c16642a74cb516328d3aa7086b3cd119985c333f4219ede004ebfec2f3aa0ffdfea8beacaa65e0175dfad9608b796f642eeb93cd38d350d19569bdadb17f5ae3360c29bfc1164178226807b860b52590c6d76f4bff900ede6cdf078c72934183a8ab8a294a3d0f5b97cd91764cdbb2b728e9cd4348ac38bc84c6b2bec313778c0bc11a9da0c123fa3ef281b3918a0d90f1fb4809c0b39a64fcf3c19a834e4b75bf16c41b0a76adc6756dca98d6de7f9ae22fb22e4fd6644129e2097ecd83b5b449d3b6a60f3aaa6db7a7af425dc203a8066d0e0e830b4a9f74b530945a35d0c11dc4ac048c750909400749abdf06b9ff96e87b60c0d37c4daba29b9841833e542b7330aca27a723bfcfbcf6aeef4b628d9d70574918489fc60628b1258cb8b1d639865c74644f0910d8915cf5b8d45027f6ca9f7fe446e849288c86f09231621814f6345c6048b7f0d11b57366cdc23297e6ced388a3e060d5813f56fa6f3e949bb67083c39418e8fec9bc7b21f827a5cc55b9425adde1380218319c651569b9692bb4f0194ac85c2684b4f591c8bae7b737b16019c230f57e881688addc111500f19d0c20c5c1e6ec6f340aaefef4c87ff9445d9c5c9223b4b3e560ce063351e2c082313412e072560c8e65d68432e1b6d3c8fb618ec7fb9316dbb0a7ad17596e972e71b6266032f1f5dcdc46dc762f0bfe120808f335ef8f76b97452078f634bac532df249fe0447f3c9a6abb0315250fe2f0a052a9feb2640d114077a7d4b48f6b265fb631890791ec7231872df69924f49821c0fbc2efe5ae287d9e87965a700bf18178d34344dd307a8d2c58e917f6ce47d5184fc2363e679da6fd60d09814f72804f512d77134baccdab5fd2191f13b92ff194df99843584390624ddfc78dafc0a384c704be22bb99b5660568585534a2a579bf294624ca014542292bffae0c973cceb7277d1032002fd668945c9ac12752435dc6608804632f100cf05cf526dd605f39ad6c5cc0c5bd6f777231d6276b56e91b01dc277e7feb1a43aa7099644d3fa70637305dc619a5162c9d664d91a95d872d4f32b4bce2454e6795f86f92ca892d0edad6f1fe79fd8772bb443329e7c1b618e463f1dc4cb280d1353c9aece56e6c030a7ce7995c821c126c60f5c7a0795b58ca80a3f3ba2694589384c828961542a5357e6fc419141b5b4107825f672d604ad7960b07632c84369ca9ac73ec00304b690d0ce4cb06faf6fc1b990a72ee6134dcf64de96c81414c1353d17bb9f16c02b0913881f998f8a223f886fcf14f430278aa937c3e9cbb7206c5b953a99cf02d5f727d0ebcac5bb5128d2c98af05f8957cf54efa0f91d17d7d71007e5a84b2e4f4f3551275284182294f6676edad1cd3519b08eaa1415baa2561bbb8020ce5eeda2226323b0255fca1e436da2bf481c83424335d15e5d49626cd532e01e09e11ab9cb5ac56b7121de5dc91551d060524c4b2a5f51ce5902cfbd68c279e9fe0915cf571259b3e5c4acbf6e938687d8e225a133eb33a9f5f5610cb80c1125561a6d273d0d6c74f724e8309d8bb98798b885f53663f7dd967af6b694db1fbc7e4cf27138ef6e7a6c84bbcff546085d31e925692a1b3500785876afbd820273fcef41a1bb12800ec9183afae33918913da6a07a868dca9c38fa54ff6dff3b89ac46a8200f72f0a4e197a9ec060b6475ce21a0baa1b39a8b46cd6f25d15c08c4bd517b641302a9fbe4bc99ce9933e614ac8ea5b3137e6d33c944983cde1e618b85ccbe3efda30676ac6de0e9735452f8f9e6e9c468181e082b24ee0e35e05aced8b901573a9688936d8db01c578058f24323e768f3caa7fdd8d6442da01512460898b299277d7ad4b5effa8760b28dff6758ed0a4278350e0304df2ddba29e9fb7c7fdad16fb33dda01faaa8a64117bbf4081a18b148c66c536a719f09a2af19b3c7ec26a83b3d2a4da168cc3bd3b250b9026e9c3632c492e6b554adf9e7983dbf26210af447228198f0b67142da2b8636360dbb77b818f4426375cd8e46cf7710409ebffbe1b38763c24cbea2ec0d68f3c4e83a8b1b8b24c65838cbd45ed9ac8dabc7e8b9fa1413f9d676e36d0cd63b4a4fcbafdf0b3fea0a18c49ff652384eb050014b9801ea46ca41ab9a4b4085ffb55b44d952d95d93578e85c5c6f62a39afd2dc05d2a8ed0e17ad937343709332ea04074fe5161ff6577cdf91f18570019fca37d0037c96efa13eeddd3e4f91f1d834959d9ce5e1393d9033536c9fa1014b2f97d7c052429d4c79936b3a03f636f4729084613d1fb3a12c9266f2018e38d94d7a2e03a245055e250a2b3ac6a3fe353f0ace240cb99f51d65eef0692deff96e45f7feb72b7c2030bb13b7473d4ac2a188c1d7511e503de388d17b6109b9bae4e213df71b8d1d22e09d29310c0e01be7344aa2acc2f53bdb217349e205bc02741b1b50f4b24ed42de3afe8037ddec8d68f7c1586cfc0f173503a8ad309d84852591c0b9f87065cda3a34331899dc4b4ff4127d8bab4a1b37e501f68f67380d000ab6228b7006223f71000d1f072ec14ac3dd16abac79dfe3229af2823e5f58bb23d6d58bb4c1c096f6801c5c1e00da3b0de36307370092b5f90dcd92ab26788675a33f5c1546654c92773f046892806f8872c0c2cdb942257684959571c6c5a49f0e513052abb04458dd2e8ef7eca4a289d60f2625a63623b15660a057fde549ed601baf567a22e4b9c98950888bbd0248c3c92edc910a38e3c4b584e8d1d6a308d4b40c67f48e39495ae2605c2cc024a254f1010ea9826af39b430050077c0a76c21d8e165c061693fa08316179145a0d903a53b5a354b6ad517fe62f5ab8a2a2f7b1bf88e5c9bf5557f08c18ca371abce5834a7bf9cddf8acee63365472391b2a9f711841dac2a58874f50fdb179ae29d8b88eaa02a47285764dc443d551dde5d7f981960b827f3a359d29af6527a08c962466de1406ff309b10df56da8f33a446eab267eb05398c2758425f6dd76998f08d571bb914819605bc4e04f03e9a7adbe8fed578e6dc7e640ba50fa8747ca2e2a4b1b10876eebb8cb613fee10c578a468ccbeb67c4996486d26bddd4c65f385dec7b573e0871f4a6165c69a9e7183432e268161371abe0caa846329e21b0727f0f6395c2241a783123374427e1757482bf7555ec7b319b3828813ea021a0458dd1175d4d12b5f6a9eba6ea2d5041af499236dbac4aab998f86b9cca0f53db244c148fa018ff28fc9411f63e34204f60ec216664c00e9b772d00c731def8e09fb4d0818d1062e0ce753d0b9f230974310c5654bef8aee7cc90fe508a1cd903cd69f3b6b24097597509484f485a426e1c0158422c7f1d63928e8f788407df69a30375e368163216a7fc958d08051c7fa794682b1267da2b4b3b2a0b9e33dc820ff9b086a7e1f9e31984ef8b32878c716e6f3ce960ca822d043f85508a64d100bedc30d02cff0cf3c40c688cac2133a3042311e3ec834918f3debe1bbb657901ea60defad744a10f1bc564e708ff081801c1e734fc338ccbd02a8e2158ec24118dd33adfc14e28e2bb8fde8c267e79e6c7a5292aabe896f717c4eefa336038e0779ccc9afd4a7e31a961f7d107f179e3422874937dbfe91b164df0a5cf5480fbdc73c6d48009703cb9c074e0a4b54c78451380df53c114ccdc4ef886163a4bc87f90317d2b85899461334b0feda69e0930708c2409047beb327cfcbbd61e9d405c36bde7bfd67933582ac53d24b404771585894d73c5d17caec0c8bd5f2295b3721b25f6db231abc5e5a3d2fc214457938423acf7492331384dae59dfa8f3c5ab6430fd4be61eadf8e7741d6d993d23a9fc3fd6e750582d9116230876a54ef70434d156bc4152f0d1b93c1cd74eb9a4179dcde93dfcf0db5afc115dff4ae7691d1f10dfe51016d2e287adaf25504f78b0b11b2f747e305eaba6a46f3dfbce544793dba47c2e01fef8dda6b8f6cd1dc491184bb700a1ac4899bb948f444128ba8d699678d126224b0545b82ec5343c16297741be5464de7f3f0fa609ec7918fd17a85ed7a25748980eb5778e9c60961da7b2cfacb0c8344d441bb6a8a9c77087bfbb626d25588d89fe3d4b518ee1c228c8b668f9d993b01e7af6d756930a58859cbb80706c8557c28b3dad5d56aef22bcfc2638d09521c57af08d6743dccdb3c9f12cc6732c87f0d114c837db0cef5cf4bf2ff78e5cab1f0b46d1ab9643d1ddd238b43a50930d093164ef88360900de57bcc6e9c32b04b6b05349fa67d3d6617876e60f029e0bac53cbc17f017f7a953a8d202d7ffae138d4d11135b58a7b7f3a3ed974ac69ea49658dd2b96819d27132a04607628b8ebb105b07cd42c88bb32a0202b813035515a57fc5a71989dc1f556ce6231ad8d39f4079c527448c6bf0c379ce2580abf00c40403d0f7b76d50650b2d1385e3a216aecca318936c0bf51f1f39b84b0df703ba71144674ddaac6fc40d7d0b6ec39517b89b0e1d4a6317a61b55ed8fae571990ca70a6737eea48cd751f6c65c6206c1d6dce30028bcd692011251b1cb01a10612cf4f6257b907d5e0016a259e03769d548b4ad62ad271e7a636f5f05d167ccb1b08f64d38db922964bf5901872bcb27c79818d60118e4249cb5df73844bcf2668ef46b99ca9fcf0d294da8394e6ffefb061d07440d1abdd144a37f2a97e8227aaed43bd5e675435323201f47c08058cd45a8dd5c0285e26df26b071c147b2515945fd50894c93cfe50b17455c12679faf0c9eff237037c7f6809e194586d1672c062216e6d53681ff055ad948668937029d5282a004c03addd158345428466017f4f2324bcb8305f574619b8d1d264c81aa3998df62f49169a1d4c9c8475c4f0791a0063603a501b5bfcfa1f6a92e6f744e8929cf89611b2018b018952a2bb87bd78a2c10d7197c97aea032ca4e0867398b63d2b4473f2816f4f9036c74089a5c43a3b3d46e49b1c34a8ac723e3047780ed7e87c281d11223b6f325b2c9e94d7f1d45ebf54385982b726d59da7cca275f00aa1fab8cb1e47a6b6a78de5a5f3acc652a46779ce31c9581c1d626817b75b559795a2c1dcb373cb39b226b6b62e8c789ca139d6ab5ebf19edf59fad8adc4fbb20ff0f765f2a81207f435c45345cf2446996c85b2550e4997eb1817120e0a901d895183a80d064681b5c9f5a6227bee608987aa91d9371421b0c96ee497f05cf2d4b958b5050262dab3d2c6497bb2971e85ad807202fcb6f2d1c3695770d9c88382a23ec69199403d6eabb0cbd93875335a5ec14774bd5eac321abc5ec90ad5ce10ec41f09e1556372faf7dfe9df50f8c465d1cb0baf328df8294f410999f08f3a038aeb56a5888c7c50ba7c5abfe47922569ce7ceb5d22e657cd065b51ef0487d973de8fc5cd6c3c0b9a8e393dacc2a44378c6d5ab5efaa0ac282f599cff152777aac239cd428f0032dfdd403c90fc397693612c3ee89a1af9173d913c194cf2816cdfbe8cacea465af6cc7faed9c722372e1d40918d7b3435e411d68871a9f135ebb6d585b78399e8892408210f25f506fdc2f13e42462e4ec4493b8f841be580ff4ec003f41c08c257da3fb4cdba620d025923e625bfc8301a1913556dda5ed7607b4900815544e6b51c36e7561bd97c96e949c22528aa4bbda650fd71080c4987f6978dbdf176a145badc9b9abfe1fbcfb0a5d0c0d54e3f9c7cbee9dbd5cb2760806485537beae62dace683c006cdc66989f2989bb996f51a1014492e63661b7e3f5e9b32132104d2332e9fb6fded4dbff6042becf8c0aae1263a71294f0b9dcfb339f33ed5825741d451735d21f35be6068898c2a1c02d85c5b22256a654c14368a23a36219085ac090c01a2f4b768325717ee3c16c122f3a1e3843e595904420d78e2cae9811b1ae337ec442bccff2582878ef1b9ffe796070955db3b8493de4a5a4249903abf7de3bf0d060f519bca7aeb3df3bbf26bb3ce91e52f7347074dc2bc8ed080210b3c658140bda1069a222c9f96ac1b2df37b1b7a714a9c3f06bbd17a15bc1c47064c14dd99fd43589a631aca7f7c73f75c981cd50294f72fbd8463a6708497a4dd18fa3f037305027193bbd0746fc4e4bd5d495022a535bc61ac24e511f0f5291999d00109a3bf4645d7fe53f7a085a5445581bfa6f73bf6eff44b386303d5e13509eb76c35539e26b9d27cc54aa3746588bdee0d4bc131450e8e1c448eb30902ea64c7643a971e0f9d890ceadfbfe71fdefc02f222aa31f7ab7e43feea5cc46a84d8916afeed7ad4cc6fb897642f8af2e5a5d4f515b341952c357774d112c746b7f38abb272942c456ae17473f5e0534a5c40a38bcb3edf7e68f29264891194bfe219ffe95fbe6b388057ad7909502340d1f8b96c79ccd9956ca3d06d0081455c0ef6a40a846cd994ba50d5a48ea2ff32addb40b52bbeaced96326a20c0247ba9b511051407761d9a46dec1a9da0a358ed68083dc9cb32d58e24c66471cbb429354b9cad2ac51c6708fe5993af179d674bc2a6d6ea04099e7553b0bb9c37261c41c26fad3d8828f8508351e63235852ff7de843e84af1431286c1e158a06a831f91005db040d4c1f6c29351c563d55ba2476372195eabee84bd5c46ec5067c25a24fbf986e2e10b7099240ca03def678d239595f0c58b8129120d27caf2b2597be7984a980ff14202dd644e90b3ad01fe084144f7db7225718db1f6c579a2781432447d3788be0301dc9de4bbeb50033d28e24573ac0296160f90622294705161b9f2e93dc9e39661df82f3c517673ce47498022222e07fe6e29716a1fe44aa08b204a9aa2b2972a2030ca051b404770d76f7bb5b24300c30426dd35c42f825b0f196c40d3de714ec8fa11508b0c096bdb2111450329c1390848486effc93edb3f600db756cf03fb6fabdce49b9cb74474f7930f20fa6465c0efea7c75ab611a920c20c8d4efd2ac86deb6a0990f382b962d5a129499d18b7b91fc406a34450874c9b9212de001681f8820415d6669a04b8a3b8d8bf34982f42d8b8faeb0b254f099c09981bee0738a2fc3e736926f858d2e4812c06356d6093352bd91433876404450ef801907c9b295e20e8fed67c8b10843819f7ae4d0f77a460a2681cafd29900c1a1eb96ac24bd09dd658321c58635deead77dd2cbf7e9fea09199e6e7ab312abbc71e1815a1be246ab02a620c1eb3d7c4d812b6131609a2e1a6245a91f450cd58d10269a657a70439d46d676f6fe94c9194b6c5062474203d3db1d80ff581167f311761944379d935efeff9278bb0772a7f04d33e3bec82d72bccb1140586f480b417bf1888016cc66fad1051d0072de03f13f4118364aa313408593b04807c34fdbf9bf79bcf1ff47ac44f023ef0b5107ee92ab9976b8ff59c24650fa909dbe5a40ac7b946484f04ced7b8b2acfd01b6fd1a0de3261ed9be5b27e827987a2f0c0b3edc504d6e7d514a3b717a6adfbaf05a8d13c32d8fd4adc66531a909ef2493d1718fb79ab9131982ed3412b7251ccb19bb9561042f3917679f78e9b2e904c5e5d26d52078cd0171caf2749964d460a8c6052314bb9507ba0165de4494433dc787a89b73f3fea5138e967905f1808b8e6bceb153a6b30294e78b4419568f776dd49f998309f7ea82da0db3fda3b33a395a4ab5d0a04476ce2ffc31fed5218004c132d4ab9547e37452e8aa0f7dc92f9acf009b4b20e974cab1be7f580b69e72357885d0a8f8716af2ca87c52faa2fc703cc5e36a71c3d1e7deb907afc570ef4fffdb323d20f3fd22eb91bd5883f7a4f70cf4652417d057fbc576250f5573853fd88ef452231f4e110eaa05af197c5658981ccd7eedfb98d43540c32a29b9d0043d52e48a02056bb8f593c6294382b8a0fcdac35b79301741d0c12221781ee6ffe399ce3aee7aabaa079e2aba718f58a9046d03ff1585877fa0903365e51bcf769e0fee79ef74c8f80fb0ecae0112a6b07d0259a049a3ad08d340bb31ef34573d8658cc170f247b5d77311625c84e0234372cc56be3bf2a95404fdb7b6caaf530f356d6ceb779d600f1145d059e5f6b0b65271e9e0b2dbd0d5df8c7fd495e645d862e7d1a5cfa1129a0fe5b766faf4459302d4c8fa24f1110a39b8997a95c3a8a99e39184e32560367b7809f860eae90f5719291d869e595fdab87a7cba6a542f9877f5ccd54bddbeb24b192d6f4236e3e12ecae34ba929bf127bdff22833271bb7c8eeeb5265aec1349dbf9d9c440057844ef6f0cb534bcd77bcd7319c05a29405600f03ece0af47f1aeb0ff1c1cf0cf89864a2e211091568275524a4207b2e936c42ee5e0828c858f2c248f0e0ab75bdfd5916fe3c9ba7f3bcbd05b52588609620aec289286880f02f14b649af07f03b36309032c0e6ff26e63a092744e0fb68dfa966146b9f0a719a13696b132e147ae2ee1f272a5f6a5f737e0f6ee0f191fc0f9b5c03b6c10abc61135532455d9b5cbf4057c6b1dcf95cc3d08617764c1cab1f5c12a2f5b4da98ac701741877d55cd7d268574a6bead508cfcb9def688b3f4278ea03febd0daeb2a55eb710ce5effe99272b6aed12ae9d68cae74b955e68d8f0cc7e0b5b449c9743b091004712550d91804c3e8623cfc685ad34570b506ed0e6280650cd12d18a655422835a8d4a02310097eb5e8cbe115f3d25b98b126f489827f442a9c092b8074dbc8c246ec7fbd51ba1bdd82bcb29fb77b248d3f7ba434443223576373673fbd61cb23a40ab90fdf534f73a8189b5763103efd019b960be3bb485ac1adb3b97ef8f14466d046f3ab131abd5d37adf2825963e7871dafa00a120e74c883952e06a94f82020c0a2ffa36115f324d9adcb6e4795f9bf7915f54cdb129fe8a1906be31ad5a345d1bd9aa97036a1f1c2091b706bcb327782b8f871233d44881c013bf0689a26c838a3942fd6f2c089b98f8e0c4f3ffce64fc38920917ec6bdc5637a457b1d4c81db99c3dad33eaeb1f1aaa2a7d0fa9a5da13ffba929da042b38fbfe6d7a193af2d6a52042e168a3b570a391d831910534283ad3ec35361a8a89db89af1ddd0ff8f0757677307014cf6d0f9d9e5c43285282340a82290dd01a994fe125457afaa56e005c04a6cd6106db215aac8b2b3efca0b7302134d68f83acf236f6655d430c339df78b452788065e68df995f6dd352290cfb833ae79655941b5146eec694748a797f20a92ab60e7ebc8959b4f87bd3235ee4c53e342edd206d5ba1f742f2c1bcc2b640aad67c619f32b225b3c602907a3b38ece5b57a8ffa973dc82dfeeb329b78ddc4c0833efde181db1f80038b0931d8f0b9d39ab1f00438a7d5e095d7d66bc53f0b8f049a7b2d091a4786359913b9691f7e24f69e7e46c0ca6ad8f951df6c1dc4bebd2a6c41d26c29a2bf1a948782803b58638a59680ebc7015b48ad6bdaa5b752f4b3ecddfbaf7da6e53e592f6d268d1e68d232c67bbe99e8425dc8ea3f9381404eb37086f846e77b5443d4bdda898c1a2ad4bfda890c1a9af97a75d10b6112081812e4d3f7b75865a65f25358753fb6dec24ac1f9ac018962d6bc2a398583a90d0c3e755537d23cb9cc937780788d28d5e5be8a935551bec2500ef7fa6b2f06f4e0bf7f0b664d30483eab754458efb28dcc0fe09337b69158bc95f675a23639c812177d3d382393b38bd7e034d38287d852fd2b2d57d8e0998368fc775642f18976cc8a6b1657c1b305d119bc7026a9e03983c9ac238cc7bec3a521e00826235d37a8471a3199c5633648044d07e311b099da9b0edf746c90955619ad4a419d20e428c0c356ed6a87a924374006b5a074d9d97d70f7343012e842d42aed403b6189d0adec8b4e0412c771f327c6021a75cd6ff7b75e5db8857dc39c071ba23a8ba267b97370e5e6038d9a67bde54399bfccfc3d0d1530539c9f8e08a1561dfd3f6325a8a73bd44099fefe53d6ef9a8139961be643cb41eceb97e233bb814d97739566db67b4219bd780e69acee9aadb66fddd98000b165cd6ba400d3581e9a38db1e8e907f3dbd03e4e5a9420db8026c63d66494e5a9c99f274bec111418df15843c134581c13945b7f8b230dc870b8678c9f91767bdb405f73dba4e59f144b62872e3e7df1501b3ae221a8b8d00de31937b0fca4c17b6125f7a1b7e524a78a28a3154bc4ae2545a6cb8de31fb47688880e6c88f37ca521d6c2ecb203506872c8ec1e3fc2f6683ef3623e490c451834c4cf9c41491c0813850f6bc8f868dfab8ac4b90ca092b3dbc444d9168336e29d0ec989578eb988e0a8a2727fbe1969166c378fd508cf674be20acb51e5e8c4a1536f04dc004146912f6a5622c3104b097013b558aea7605ef15d008b0ea1ff69870fa0b83dd8298e7ec77833fdf1029e4413dd8bff1599fc70c900a8fd866d13527982264b41102412e381ccef188ea7cd10827c559270d9e345557b4ff5d56c2f7b65246fbc0c2a58ac4c08d43e54412b1ac69ad5492ef192a39a326e2bf7ab5bb0a5eac7ae23378f0571b22b5071dfc3517f35e21063620014605f17e1d2fb30c818e66ce0413372b0e9d6872185990b2c68158d8f91c7348bcc2f850acc7674dab8c6de4e51ec2f653da2634addf1031a2b4cf4ce46d23e8eef6f1d0046746609ce20dffcee7bee20170839d4d972b25c2105524c7edca71cb818664ce096c1a85632aa7e29ee1204d749136372cdc595dfb315136905fd530476cac76545bd3f73bb8219513897c5e13a7f115212338627fae5ada3258bf68371541fc970982c66410d7d3e3bd1224a833e6e1cf8b41d63e2ea6ecf1beeeab373b72a5342518a7880fef87a5a9278fc2b7d5fe3e4480cf4b487134a459d14cae3b6c8c462e9ba1d5939ab670808541aada263ac37deed6975d5463086e7fa70dd819b5c5d4d4f2dd89f0d9884c8f0dcaee88398103196689cd894f344ce8809ba135694bfd1cc998516679aeefeb8203bdba51b8bc001cc01e3b6f82439b8db9fc5141d01b61d8a8ec501d6080c08d8f3e91f8197cef6d0c51a78184c68a1f1b610910c43d9ea29d5e026da12a3e542737e21ba08322ba6285f348d60946f84cf6cca95eb596f57406c346f0bc9ad9dea53dbd9e3b025522473c1330a614adf50912ca8493a79a7a8f0919920d75ac2b9e38e32878de20b41aa6727c536caa2f41b6b695c30c0ef7379230ed74aef1c031ed6579ef0baa1ef5fdf4d5e75f542afda4bd4c2a4df2eed3b80730ab46b998cfe45d2865814ea9906d3877d08c01200001d2a58244f77c04ad5b947809e0a6d8f92b6316df025801da8e66d70e89995df263a5afed8572c997da05c801a81a2892c361705126e9c4bded20e4718896a4c2802eeefa5fc8a19b2aa03b94294297ec68de148ab8bf7453d6d2ce558be76b006b627587eb6e142b46dddce08bde75a25f904354d3f379f9da1d38495e919b31fedf143615f1e137021da413acf5cebf04b3f67fc8104502361fe74f684c039112903a7186d3b0f94ce1a5721dce3131870b997b42cf34caac1bb3642fb760e6f6e58da6c8d025b6c2243e6acfc0b2781213220589e8b6a734330f9b436b2c82d28c03fe950c355b01155e0c68be80e6a332a606d060a33e5f612f96b96c0dd2ca2de76cc7e35b2ff723f53301eb410b850baf7608422a7c1021544022924e3f7c11484b21d4632bd39963568d1575086ecdd77d2558d13fec3ce5f08219ac39508d41bf115634619c18cb22ad532e0bde32279f9fc8af6d52e32ed065739fd8a922c405380ec49ffcdabdb8dacd7cbda4735b0127e8303ec053e4114f44a258aef2d3c8b39b2f4f3742a94fe45f7a107280c4ec5170f271d9523ced895ded4bb858d09bac98da5318139c47e2ebe3614a44255345a1858bc9448a2001b22b0a15e4419fef284e227fd2461a787a65351246f2f92a05e61757df1ab03d535a099b2031999ea86c7191320e8e5d01ba7587ff0843fff341089be081e12da3676bec0bce7af6359a05ee0120089a0825eabfb8d19762cf91186dbe2f213cf997c50f87c57b1c78c5153339bb0a08535232ae0f6cfc181aa03d7119f0fe3a99670e882ea3e37e20965e08261c4ded9a67a65b9efcbef209ff92dcb84a279e7576e5ef6b9f73ba49b3e2a56c105da3c46c62e120ddc46b55340b7c75a3981a6efbef68dbc4ae1b0877498e32bd746ddde0d00a0251b62e1bf45761f73527ab94f78ea450b3723aeb322a90ed4de820e7d5a2fb75b2c202ac73f5d80803af61d70346deef46666f2bb9099aadf19c96f39f111c3fff024620fabeef2eac4a87ac09007adb763bca20b35501668c80063cabcd955eaa0183e2bfad38d55d190d49b41dabf8ecf69332c001cd151c5ff310b4916ce98ba08890aa8a4bcb99fa1d4191dd3c058edced34de9e38bf23b398bdb2fe5115a49891530f727da727ca65441b80bd6a20b2e0684996e792baa33692d2e252a9456de76a8ca1920fc5878b83003ea1a5dcf799c6f9b1ddccda93717f516753e0e2a8789a7a205c5b301551d511167e962f27441fc95c33f0656757d0b5dee57b13911444e8877ef0539b3430d34a0bd899ced32930d515f997247bd61d5d9455e4a6383da5584aec0f21b94d0e976eaa476524bfa6b1c2c3090d9d395744e595abd6d40ef41898f0882ef4a956116bf312acda1fa9663d285369d5fe7bd49ab30d6739afc26a3bedd49ce6281c688d0ac7b48e1db21bfad23999fe7e5b2c82c02fba9e994b520a5eaf512a4f592bdc0d0361cd4b3f179a8f359fe9b6bf0a11fe83330d0f39d33e4f592a43b720e5c58c2ed2ceb1f42696529a8f64863cee44cc4b27d77205d778d114c57c6baff22301787f8d39a324e3c628bd75a1ef8446a95d353864ced81c0c86e387a9b96f8ed4f07c87640671011f9770608e68e50d886792c8d72d0b68920f8bac8a7ef43a91d02950ec8a16aa460cb645d994f770c9d4424570b2e9386d549a022437a5beb163985ba0159b7f5361eaaab69114b1de1419d6fb2a7f02c27a7df4bfcb15e8230f54a2aaf157cfc5b6b55d339f7d2fbb835a6a4e030792e4fb853c32ba5413e06b9db7b9e4b87fe1aac032dc49fe929c3de9b02ec7d8a2e4ca42952a39198f79f78c56e378404d1f697a5dda78e9587463679f3f1b86fc88308d984b5d188fd1291eb2a49ea0179cb327f28a371ab662230d342c8222dcb4d1645c34ebe2b5b1956097ac954f442e6c56fe6d4492f8bfa1bedce72adc39c1526c3b530d1dd44fc9a3097423b565ec3597d1e9a5adee4d95d25269ffc01e35f34ffd13e09aafcd1f7a13c98ba91ef5bf017cad8399d425cfe90488b9c5ac233617766139da3e82bae916d19d7b39d038a785d8655ea6c7c01142c604354d6963b0414260a53c2e46009a906deb0f98ddffdb5177e8336978bd14a3c7113533eba9684979f74531184f7c32315ea441afa280dcab99648a91d4ba8bc368fdeb6cb02e24df7e24e51483cf1834cab83762721a02c30a2afc291ca675e23270648faf804c04c5f2981c5a10c41d999646919a4e0864d88c81569c8161a9608b60a8c136085dbba2f5bb4b8ddc29826dec26a25476dfee82ecf67e0407558893b304d3e415207b2cdcdc46021901ea02498d203ac0b0528a13387b352f495fb059437783f893a41a2de214d7b63d52e40a1083bae38d95d519cc3b59b25ca8e80db31bc46e42358d415f4b17c3d856c36087c172ba3d942ba49c5f6433671537376e91cb3c09544d4102bbc1694b61e8a8c487fdbfd42e836fb342bda5f1be18ab373d865603831fb345611f924379dcbf33b7cd393d7e926d12b94335d6fa56407108b1f0d85baab92893e9d308458052a4d7586689fd0b35dda8d9e46a5f0b41826f763c21aee8de21b71762396735ce5ad5896718fbb72b11bc19152a2f842c03fc8d6931a46f5f114b0d13aedf62ca8137c4512177330669bb0bb16bfd84af7135bfdc60a83a917c63fffa48df52a5c0e57a7241225d485895705e5fc030a54ec8474f233610d866dd3355735285019757460cc25ca9ff044504ce5328bf93085bc37697cd2873b0bf6453faaa2757d1e5c20758b6557bee550267482b523f4b9fe2766e0201b8c746be9e7c8429e29fcb38c18c2f08fae19f872392974a98605ac4a3ff25da9de06940aed9518b26ba75ca6c623467c82df3fc2394a117c2ab1e6a3af215251c0d3be7de5cad0b7508b04f2be3c92c8d49f2d40068a90388f191d2d5c14218f5a7829fd77e0ff8f4ee1fcb0cb83b45098959f5812da29398fe6ae18b1896b00a69d0d4f83389fdc5ce9d3dd5f55a1adcc13f8a53a5161e6983fab371be35ca667b20546a05577e3b9cc0191c8f418dfa01b5ff7970b21876a6bdb69b2bc27e8d3362dff89dd6386a3bfda967e2e45492f631702608e08c0b577be849528550501eaba6daf111201692a1644e4d917a08420ae9bd4433dcb39d47ba6c743a47b7964aa9fa5280d2916899e7034b3f03b5fa7644096f55f24185dcab9ae60929e7b9d58edb0749183a3de7a1fa30bf5de739591ebe996d35bdb4230907cc66ea4155217176c960c2cd14d464c8451feebc2aaf9287bb63f499d4a911b1a7088cb869386bfea206fe077b7b7faba9b4d27a4b46dd81ebeaab95d142a5290c4bbec0174cd276536e31ba528bf2d8cb42e2e474833f71aaa852a67c961c4f35ac67840449226d8f6cc05df788612f4243d2f85790a7d2415d8fab8f0984e5dee580d1e37a5e8744367223c0d6871891223a22e820ffd7a04997636d1bc524b25dd946048954c60c0bbe934879c9dd45117ea8b88c86361907da14dfdcb00f9e2186d41fc235214219825da0409620a69b88cae3802ed83a0f0d60906c4e751c4a429146405a356cda5f96a1d11566453182deb0cf7149bd7934a6ee8a81228d42690cb0c4957224a486cf34f1791f094c714490e41e90d5402318dc039ef19880c74b038ed52449d55c10c6589fba2561be56ea2e3cba79b1fe4ee1971d9bb2d76de03e974c4b2e47b74b2eec35f53ec15916c9892a45e0feb2788976ca58294d6e4a5676e5e35e1c02df49f1fa2bc026e5e0918455d0bde5bba33d3f2f7d6da529f9ea9f68f63bdddefb6b339288046a4c74d72a0b8e528225e799be91d3815a1a7577aaedb9419d642407bd820a166419efa146a1dba420e0459ecc87f51b9350e95825cb488c5bf7e5a56ed2f288b2d15082d3fdaccd5c8cf7aea37988d68c9870ad834281bc5616d13be810414ce1fbc99984901ce363a458f78e64069b50928e4428280d76c2a2ec7f800a915fa76dd43faa1b48bd3c339358729195f07f690e129ecfc1f96b7f174b5ee4ae7345c38eb332dfb8dfe13f8aab67d58bc2a3cbd68d9a5154cbe52af7380ecd772a7575c4634f1a50f929069768be1b6fe258858ee84942a8ef9443f7d6b95a6946e90ff24fd185eb5e3d293496f824252c9ac6e3d3c10b0dac9ea1b5d507ca3a7686ddc427771743e98e79b0b7a1cf94d57c3a46313c37d153aa95f4a756c2af06fe325046ce02f8e681e21c3b961a9a345eb434b19d1645e373f79a9e044530f91bd7c0e5292d8dc3181459938d582e67d63e886de4759b945b92f2b5ce9f3798810d378004e7edc160c0c0ce837cc720b0ed3a146414d1f46845e1f62034f09c04c271416723d66ac02f9518884598cc34a8c43b11effa84eab2072e9bb122c8ad5fb3cea4bc337e6f81f1fa0d67d9b0738dcb0b483f227cad18518b9aa1dcab3802a3cd70ecbb896070d98c0839bbf13984fcb3ebe9c100eafa9b80e5120cd2ee1db0683afca92c135e33496853f36309c1e4280be91e0abb773ac1c21e76ea68b64dfe58b77130ae03f657746a6f4a3d81b9dbe0df0443d93c66e9e7e6b9108dd102802a7238a5bde209608c38df60bda86405d746e29a1704fe89e394a773a8208a66ca9e29a038c71ab4efa190d0b853ceb32728cb7cf6372da460e01331da3f269307668092c129b58af8a78dca13f54b144cda64ea61854d601f569ab58cffa0d3e876fa7fa2a2604aad97e743fba638e4ef329412f8649f0a606e3cd9587a37bd656e052fc38582fdbe854eb0f3047da32debecc6d302ed26dab287b8940e89237af64bb6507e8d3b94b2c6422e61249a4379039f33cfb2d0a7dadefdfd825cb38df0b788d8a60f34f60252d2ef490adf8ef27284f3c8186e428f5cd868334befdef0cfd0a6f610dc9966e39ab7228135563a8607595b7e3fc484d18314826504d766645ab18f56259a689c4a0b349311ec832117cca5edb963eb8d7801b97ffc376f6772694c40646bafa0600cbc160c1ba3b575f4d4ea045e6b609de53756094125d43c5d67ebaa79eb2b7f4dd9807f2b1ff3c635ba05353123f192d2cd1e95670447aa6a0c87186e99fc842593e7c7c0a8930e01959cd144c65aad77b32d72b19c3a55965d898576e001426a04a5ba1424acfa8235664570c7a57683189a2aa281dedbe606da9276a6c4b1c5136002ace78c60d6d28af9d0df21c67b3ef7a1555cdd4351c448210309d7f51e91cec14416e715fcd8c9ddba9cb7085b4ed73dac7c339139e94839a645461c82ae2f0309f1453ff08b578e283f5d76cbaf923fcc96bd243d6926af198aac1db6cc55a8009f07ccb1276ca6be7ea3e718c92e20db3f87bc443e65bbf96c0b83e8ba58db5bd18b58ccf667008721ee036661ca00b924d69ada936635a555162a570a7f9cb47f22148e0fab4e8fcd9f873bdba68dc0da8043eb20c35630f027da02c3032fb1d1912f086807fc29ce449d69d3fb9d262fc0958b34bf899f233bd431d14c5fb6a73f8bef60f34a07ad3330422fa294c807c16fcf859b046c64db7a21d9dfa635b9cbf3db54ff81837fb6a87d86be498728bf633a1a545ece6f34ed6f2822953a4ca884c3c9d73ad48047767340cb59ee3baba7ef1499817b1307e57e8a71686686b0614ad4a12a145b78a29b9b3234d4a9b1a59451b83091a801b8fc774d711a7e53b580540cdfa1f49b5f2439c807f5ce4d5f773c476e20451d9906dd603c0098ce40cb30f885f7501c30c9befe0e0a944c4c81428236ada157cb41f1d4799b572744636c0371412024df699ef70a3475606b77e8fc146ceb8c16d12cff039d99d3e025718e23d84d2c4293d422724408a91c4a146311fe47ea3a3b310d98f69fa9e5cb2e7d0d00a21bd6db95c214e000c14c5d13bf382bded1da5b3f7b6462ce4e7190a0f0cc3502994adaed3f8c3a7de18783533e0de75503171383e32580e0625c6a3294631e6643921701b73ab93456ad17608e651e4832a20f586b0547c409b6a1ca0a8045529dc596754ed7059233f1dc4ab2f8d9031da4d511448536befc5ab499746fc3f0c97f821d35ac3785289faa5ea77ee09806fd2533296cbb7041c179e28811adde31f7da23331a62328d834f1cf92afa81e279cada3adacac5a63cfb1e53ff31d0e9ed847252b8fdea9065c5ac3bf8035e9fb9df83d5c47c6ed24b71884814574e1671b3ea8997fa045e30e607eba677f85df0a72c6421b5313228f3ebef59d41a68bfb072bbb505d874ac26ac8b12569adcea07296d4eefe69e96b1827df425be81ec5e047fc49a04a21a31ee0f7517446d825214a6625c2a7f63c0043dae9381f9ebf2602136f20074f72e0e217a47822704332ebe98f2365a1e93eb92c03978d06189edc2494894a742c2e7722c9abaeffa767798b223b1e3c5db7f86cbcc7da6505ca6ac607755a5080d70091d95454d1c17907befc9679aae17401431228c24e730d40111e9e2bd2d0b549a4b22949f6b01beb78aa8a4fe4854761c20dcc35e02a64e2985171004b452f91dfdec49d00f42f17a4fc79bdf205ad0ef36cd95aabc9417065a8adfd4c3c3559f2f21499e3747179b41f2f4e056542b61469678d4071af73d42ce6ef12d97fe40b8e5e4b9621fdf4745841685c06ae929035605428a776aa87bc4e8f689a919b98c1846e4da1cf983e26ff06a09c906838007447a6b0877fc437accd598b94614b51db34ad592291bcc9ff33f7afb946e7932bb177e30ccac983a7090e1c3c26f4259610f94cbc00db047aaf33697affe3ed868e859c0c4815d89747344baa2be518cabd8ff01c40c8e2e59ae3ef554f4788691b03e898a60ac7d4c9dbcdd9783380be34b8c560c26ee35ab62a9b8f9ca4ce3dcef92f33ec6ce7d294eeea0cf0df8e0ecdcc7113f60a5a0ebbad2116d855bb2a5d6eccfcb23dd0ba8646dfc7dffbe5a619aa41178ba7e621dde84805b28b7452cd43b7f9bbd97de24895cb54a5ec704d4cb129bbed06f6ec50688e2163336b31617b987bc54520a8d55f02c2a3295a284f8ed87c5a4eba825989b674a23b78a70017e24e9fbd6acbc8f67ddc789443f266c80a1bacf217e6aef704e90fdb6150d5c1825a3d7059c7c27610143d1b0b2753b9bd08d653475321ac878e7011eb5c3771f0af724d5ddbd2b8d8ca6853f2e6f06b39e956feb8fcd0d4392f55aa0353f6213e3df68e3d41f21ab9e4a3db70ffc66630659a35c01feee6cdc6e9e791c4a5e6aeb5a5d7d13eebc603d9bef889306242fc920c8589b3eb5cc008b8348ab5a74431f45136cf2e2c97e7d712b139d96d1450d348646801c0c12764f9c9a1c0a0fedfb15247894537612ce946f649b834e00176dab196eeb52a7c1280d81e21942676e2df7c56d18435eb34c2ed2a75da57d305897b8253619ec435b48cf20fc4831054ae90fc713c30641812d2e47bc048df4581544802dacba6447eab97904f51a141fb954d73b700d15df600b49c9752c160f7af7bded97d5d9ec74a52f39468ec631b3efc4e317957228c243a9233aa4fb8b5e49586fda45675a4bafa0430d30b800140de42ffd4954c63a3fcc47bb890f8ebb8dccd07af9f300141bef8be1cfddd4c335e2d4e16253a030ca1411862c678fba0d8c39d6dde70c8dbf13b54c7ed8331118d0fd28d5720d144a1d782955e9bab567550290afd14fb3273f7af186cb9db3132983f4397f56ed5a1ac7ff975029c1788e8dd3870f9920b555a7957eb17a9d41eca22454337b4482e366a42f455ae8b242f2cfd2769af6a22c2c06ebf65c72e8d926e5c63b0baba3d00f17644e0808272e1913f85c81cd5409b0c012cbce7f14b666f7c133b9a0adf7b6d3a428a247537938e403baa79c4f33ef49936a0e42dc6a824365a79b343337951dd35352a82fdaa6b4ea5ef99232abf91dff44f58218b83d83a9f36ed24ce3345fed7a2e269dd810efda271fafe0228dcee489071269d5c1a7b5dafedd3fa263ff22b9e4fbb9b9f3b6a93989c18c1fa00f49be0c085a80c37b76b76c917aab8ca15483c1c76ecdc3252913ce1f8796f79417b72d3f74b9b3be745fa4050188e6620741b123df452aa7d66a1532a6202327e63c4ff2e40a4096432b7122d9d522e6f87001e3c809a07bc8b266cb4f39ba11bba936ace57acb40d77d5b5b56c564dd34f6b50001c74eddba65d56d521c8672b2c2abb8a2f1266ff6d2543fdc1e475ae8c72bd3bcc995334f7c24b18577853f8b355687c9f023320967b7c3f161fdb0409b8ba5a07663814f354a686605c421b8415c9e9ece0672fa691b2faefbb5db2659be3397ff186db8269e80dbb83caab48a224f1f73949ef46f5c76ea727f63c29fd085ab3b98843cc49ab38e5ab482ad54f049d4f73017d00f7583f0557cf4ce721e4046170d7cd9437d14f68eda5018b7a61e5ac68fabca205e161ceac0433160a5459eb25dcb5cd7dba1a2249d58a8c2a6d358817858af2a8d19c9aefa059b528ca383f003334d6750a973364c134b7cd1f7eaa511c621bc503c257513b0766a50060177dbc82578029a9964953e4739c8190a7372e5fa663044edb00da4f9ba3bde1fd9497a7fb069aa2893839a9302ce6fb7affd4fd47f8f6a770d1475bf47bdb0515a5cb0ae33e870e93ed8b73eeec5379d2ef5bdb00cb87d7cdfc8512cd51f1ae408873a3b931f1f0f0e2a9ef03c2dfee996dcea1a5255ae3acc17aa779871ad84d9199a8f15e8e576f1bde32aeea6c10927715ebafc1588dd5234e3d8b3a391b0b578a569f9fe809b2be378408d1b9c4065ebcb5fccfde7aceb7fc39a0b8d82bd59dc027353d8717cfbea4cc976200964918e1b3733eed0487edee8514cf628877a644e72bd31fec43f401f2e6780aee9022ce4bbafe91eb8abf8de50fc90da018168679e4fe7489df2760299340d01d350357d48091037629f09fd61bf6cf163698340807e970c8869c3e0d563203a89e5d8bf821ce408b1be61e0dd4fc91f82361d39db9f53463e0232b251a4f160ba9c54c460860397ce32cc53b588f86517e8b2376cd92db2ec62afaba88834e327938dd4ace6a8de7d4e3a1dca60b1d098427d09bacca4cc52edc868945d0896cd722d1654eeb6dca0dc754d4864668b8554e615a4e6feaaef01d8f11387c62bef68c426041370fee64bf4f47d2b11d783a2c5afe921290599930a8b559065c63b3636382beab20b9f72b617abb8d8826bfc05153a2341fbd56484703c191b22a74c8691a5963c8a4ac0f115138da6318ac59ca161d10201b59cd735194ed597d5ec1507a0c8f32e17cbaee03146092f9d4fa16672a1879d6111549895bfc10273e166287ec9895d3edee756e5ea3bd09e5cf226b1e78a1a63462b576b6612007943b7a446865d6ae37400d77e42b11e99a5c4635d4cf2c950854528968d068fc9a57d9a6709ac58337beb22c6cf3c0bdf4bd8e2c0305581d473332708d92c9bd1118814d841b1459edf4540aff7e5237ef1c625c9dbdcc9e90bf3ecede89d8880d0f3a92098dddc414b4604869cdeac623b440366d0966d927c0220a2f41b54b9af0db0c9dc82f4edd1f9a51e17090ae3f01fbcc450c772c2ce057216729798beb019348ddf66da54e1704fc13256ef2177ab965138749ae6f0ecb4902c6a49a5251e975b656f1f25bd718cc1a7625577fb7d6bccae23deeb619d211a0909c54fa361c0340a29bfc05c773762fa8a18d95820bf7285e12dc4a0a0f0daa2ac95b645d2ae3d6f7bb3add3bbfe5a22668fd3faa65305facba2900382584ba7de271123ebc95ae29e2024bc7693f5ba86925c0130c776c207984d51a12af081fa016d02c42626ae2ce002a3d82554400b15aac179024e29a294a7a13dea05afa12d6418a18e5d918d1e0b1cf0767444b4a662f9ac80b8bfa60f50e1502d8ae77db5f63ef9d342fa9de8c64e2854878ac2a024f16ca63e719d008df50fb7321d136cd1127fdb5ffad91634e81665f03ad46a5a792596ad0c691f057c32c9f2f2a998965c19c4dc6fad11c304da9f1da1b95af9ae05ce18dc1990f7ce59bd5a9c6218704a76dc0f5e65dcc2964b95096520ecff77840fec622a20d253d68b247ddd78c95e81c72c273fd09759c4adcabb2c74200816918aea96d827461416f6a43eec5d45c97a99d9a2e5e8f825eb5881dfc08eea6fc4c82f21d29a760cf65a0d06de12d55f8a83cbacae20e2c1772910c94caa037e039393bc032e5730a85c750744d1039880dcd012828900ae40ca5dd99c1a2ba3582da59a488b0375018e58cef89d51d3c8b9a46e6de034f1154a787210a2d08f90a59a07d45d661e183d1353fc6639d9fe9e67fdca7e47ed8c1f56c8913095639fe82d6e6a4cc32a13d2f448f9d730285b38c1d0ab23e7b7bb62018ddb7c57f69362c4a8028e89b8427b9e700e0d9ad4e1856d576daa211245b3c7c47414829e61b7363598813be7c0578ab168c2ddeb5bf7be0bcf472835b58460615a1c170eb5ea5e7ec785fd6d87b0e80c6b0630d2597edd2ea2b5d2d5bde59abac4d76e1170f968787629f35d9d34b471d189bc01bfffe753de529e98c596f79706f08dae4997ce74e4e236a588e32fd891b1bb4c492b286eed29ab240c40e7efdbd323059f87666233f9d6a1069c8293ccdcb683c44e6f1b1384312280c744238fdaa6d4a3e751edc4cddf6c41ea87d6bffaa120e71b46014f060f3183ae95eeb27558b4696f3b321704d9282ca4eb78d98b46f4cac337d363ea14a0fce5f44ce4f90ae8940083fbf0686247d794f175e9c2323d6f91340110d5701e77d61126290cde150f39a5ffbbef35879c27e2ab9cfa5e6ce8f0ec0aac2df9a4104ff4f50ed17a3d30d742c35dd43cd573112c48ca38ebb90a0d600b78ad22d2889ac7090948ef59f3985f50977a677a9244bf9cae9aa77ac5f670f8c8fdf188ab61129b796ac35fe9d5b59b3b7439d4a74f3eeafb3ef35a8b6881ae870af3887258c7f51af38c2a214805545cb2a06a881f501dedd71c513ea5607c6b22d36c3a33c24a945574a7b47c7906cccd941a8b7c7944dd17e1d524a884be9e07717757bb4a936a19ca7e4fca412e451b3fccabfd00c2b126c24177b8b95679a7f6e8444a4b27d2bf42672c789647ca9d13efb92e4f994c1b524b1621992300a03ce5a36316ab5f58efe0b35a1e1847d7063690d94b0d0f5fd33a325779b2f31211d01d56b0862ceefce1fdc6beb25ce3a5262df981e8bd67013be1fd7d5a57a5b38e09e9d1e392a5c287976933d669ec08b1bc2581aee1d27c77e31c436c0c762cd8c18e6d8b6bccd403ed4a316c8ec9dc0e2f1feccc5919f11e5094b57049d70374167b2409f99da01b97d2c0e78522f74304055d97b223ff684d6819e405340439a833a865d54049003b0f2d0d2332c9f99ca421efcd86270202db6b164cf4f15a3254e06caecb6ea9e25452f76481e0e046aa91eac47d5ac17856034e529d4a07375360ab33dd564767b9a642bc701783ecc1cd0c7a112aec0f6e0c27c00a4844a712708aab06ad3b0a8c17aa63010294af38a1481e12e91e397965544bb38ab20d078e7637b1f2422ced0f5bcc2bd7d8096ab75381c88540b5cfc8ed4d6d9effb03da868e4caddde146cdd5bc3796ba485325117a6c4c9ed4dd1e9dfa5ed86dd3ef117d9c7a27acf87add66d88b30ac011495de42dd5ac8e2353323feedfd0001c3c3f035c77e6433472756bb37b24d9b4908535015f6b5d23c2323177d963fcc6be615bc5928326db7b7a3fc412433c34f604e3d10f63f3ce90d2a711c25b289e824df1742f53567d2827caaa46f8e4e9f11eebd9da83fd9574d862dcd9bb0f2e5d2c8d3b5e8dc840bc9b9568f5269cabd469eb2218c432c6b1fa1af461330bd64fdff8678f352d9832d68e91cdfb3af715dc15ef7d6f4a5b2ea07bfdb2c754e516fca81434a60835fa48171c5e8df956c88aa4bcacb545e8b36b2fbd107522d54b6ca0b7e2329a4f55a03bbcdc006b4bec696a1596066807bf77bcd444586c09cfae78f98e75f04044f14b7158333cca39e98e35e67cb6c31693e37e212c40e9355735ac8e722c78ab9b3b39b1a3204be471a850084990b3f1f58cc0dfe289c5262685ecd490c72d7515e3b26c6cdc38c4545bce7b83c8af351227d80f65847cc0ada93f0645905432a74c16730176a53807598a4fcb89315cc9c4c6b2d3940a9caf938a5fc9776c46112f6fd58b1c1b895d47f014a46c7028bd001d850efac6c62df8bf43e9de30c5ff2b2031cb05a66700bee5758c50558353c25441723e29f71851ca80b2bd5fb2cbd3d038d2c409aecc1c626a453ba3e910446dbcb0a79813cee098fd28a76c0230b3e29452c9725b93be6e4545b40be220e15729670ca031262d33d9a25d0fa43f6acc8d432ac0e1a468c12774911db10f8120241f5174dc0c568e0658f9aa9664004905750c3c8426a5c310e24272f3cbf7841172b1685a57c499908741a757f1f106239a95e517eb248b93fd1bf8c0266cf7694ea2918d75eb8c86e4d0051a7c81ee4362350aa2405c1f49d10498ce1af983243cfcada1034d3743c9d37cc6ed91e63bc1e3ef47d297778aab1c69ea79e3929580007bdcec3dd4d0c329636aeb958fc92541f02c99e55430a071d9ba17d4dd12c76357f218ec3800467016d2320d4d9db4193b89b78ffc19b97804145b9ff4ce7a69d7465de461579b948a17b5a6eb7caa65cda5b5ee53fc01aa1d7567c0d070b8dce385b8219213a3289203da12f446b1b6e4da2aa275382a662c9ff2b2ec4b126bd8c5dca4eb79a1a514e92ac519fb21f423af7c71355c79b88f6641fa94793811ab66fe9dafcf818fe06b62d7c55274bf6a1ac9cf507768577d6456d0bd3db372adc1a453000184285c8425b42dc446b77b895db80fa6ad95e835990207264d69ab90373c60f9757100ab9402b348e78d6e4f60a3fbb6e76aa3106634e1823459d41d55f2c329702268defd1a4581a3ddc2c10b1267979385d23e118caab0f4e52b3bd76b69d8912398b1f612626777b3bac3d3f5589dddf9836f1498bb7a67f750a62e44470d611d88659db0484729e20d2c234ee9a771451b0877b944c0a671cea8d068cae5556458a19c79849a1ecd52da64dca00f16c58cfd1d67f5e437762cf636056d4295bee63bc7876f14db3439126ef4e7090c1a0e8e0a544cc9159e8312db98c0a8d6fc40fed1ba17beb0161d39dbf682e403231ae2664790da42d7ef3a499f7d1fb5ae45769afb5e63c066247adfcba709d9e3f153a95d94cde1bc5efb1c806dece1d7fa17429eca848a36774ff5008a993cace8cd7613e9d98d3530e7e6ca32b8626f0b99ac738f171adfbc58d5357f4f204b0b8c690ec53d93e02b097383b0b33922677f7afb704a5e80753e3c28113fa88989f5f8fb059bd2585addae517dee3b17a0d1868b5f5049c2e4879042a2c64320a80a4eda0f6401dc4fe7f4dcadae3c68cb456937f61298bf2528993690ea7447ea934ba2b7b422ff250f75b9e9e3320ce7ffe372b13577bde42358854f2eeaffa0d06153e7da9d8c5e99f4ec3ec9d584edff296426d703017fd5f3cd5f6bc165bd497459cebd022fce86c3548bf0c88fb6c3c405637af37cfda01d04c8f46eaed156dfbb729cac71f4e3705d7e2c3bd6bddb9b55d77b1fd85b000deb1a73b56f5db842e029a616540d47107e57400b8f170d9227e589e7d01fd51a75db914c6e62bf54d45faa5e30651f0221ee5b5bd97aad79da5d9f482018c1451d9858d0f31ed39996d3c17d68a27c3c51087506e0374d949452c8c75d46224476edda4451fd3d9a70fbabb1106cb4af3dc64982f59aa9816f32940fdc5a32df5e03de8092bb27050e18844d7d687a965e2679393b73fb82f3c455369c70b88acf6872f227141fdb5fa4012b78d7aefeedf453b2e24802ff90a8deaa4a32ceff33e7d2253e0fce9421deacbe6934237e8e3fd64806eaefe5e931ac37c31eab3de39cde74b6d7656c65387387f11371894d76f0ad7994260c49aef81f175d8d4df6d59761c5ced54e2c4b2d2ec9f2b6c6a9a1f64a5d6edb4f64ff6333f7b1217b6ce83c36d01dad164f07be9e2f941b53160efc0d7a89da4ae9a3f7def7edd0c7943d5308b581c509e5996741938ba8e44c755ec524e3cdf4331a59c6d09bf4119d858d2e43a31a0e5935279c7289fc0fffdd60ff980068b9f9588f161be4f356c6442a970eb6d89534951af8bcc0cfe373ebdac614567fd3155435934bf17cd83a20dd3bf8c92428334b06281a31324fa94990a16b9b96c37c5b68407f659416f0767973963d933700e259608ac5c5c0c1941f9ba2771b4d819eee2350b4486a386f7594ad524f2427425916f2cf058c5b8bcf000d4be5c9ddefa9e37bde1dfbdc7fcdd5cede2634b24f7b37256a41e5f7e82220e51c04b43a01a2ad07691c45d31bd31abbd59e13a92ad87e27cc0515c8f91fcd5858051e4f710246c72bc0da6d60ee87c2a6d48c8ec434a36cd6453c30fe4396f36917d309ddec574bc4bf743521e77555ac5a02a891199ae1917f85e579da2436d688c471e8fadde67837fd95cabe1ca0a1b5a709e83449f371799c04ab0a4e83673be998f69e04044d7c5f3ae8869b02052d689487efdaff2c60b0101a3a8eb8bb860f8042c819500636cc537daa798ef83a0f4f80d7135609881f98ff2b8be7844f17a693be18874109955926ac7f33f76e70c1514d8863db47f35bb213463cadeade962ce8731975ce7b2c9689ea1044afd2449942f5420f5d4307e6b8f7a85a3ad5e6925b234133b0a46afa9f214cc146c09eb4efd7099667359820c6428784f1c2e88ade814be3aa8804460cc5c0ffde3a683fd230e69c4741b6bea8c128a6cd5f99c134d7181045d008690bc383f2a3315a0f8db6aee74fdd56eb83183b9768bba423401d28d4d3aa097a2f6057d3c2d49408de0225d1022938f497708e59058589882cd02c716e38b87b8cefb7a358585c10274e93c5625b4d49dee10b1f613b466fc24b036b009d79388e3589bec25f33893724a1cd48a03428c38ad228431a47486b0e5c2b8e75668d507a2f9771e560baf685652d4ea856a6312a3d1e92928c4c6610573f0972498511198e6b739f430eb109c166a213aceecac29c85a3574e16077d839e86856146a049ab62abac2049333acd287ad2db8c759e58b411a3544d9e7511b95c3d926c423231f57667b260b93e2854cb97ebfb8b49261c2f752da4a3c8fb763a19b708a7ef609053604fb9d79e87f9fe899ae11445e614439b18792c5c12f34fe16be07b541dca0e4bfa28e4f2495f0570df145676bd0578025e39ee99f1d21843975bc9c7ad0b431f67be6334497d9cfb769160b96fac35319382674108ab49bebcb01f741c2cae00d4387a81e8f362a1e8777228999dca0f1b565099c88bbc6c05c66ba2150356db13b51c807cb345099da854f2386c6dfe051c733fed75c088344dfa3e4c75e5af247fda804af26d4fd017d438e53ba146aaa6ccf00e5e3d5ac958a45fd4c185e830eedc74dba45db71a00ad734bc4317f1e96337eed79321ffa07ea2b2cca0caaead33a85318a6238736337d17fa6c8e7392b18ad9bfb4bfd77a86d9a20049f91a780339cea9b4f254f9e1618f1a006076ad245f3b56fbd0e98ae488857c3357e46f12099f1d38a0f10c0090f19827aa58fc1161ba55c24192809c1ea2844cca004855a061d8a9e4248d1fbb8a2c8472ea052c36370931c39f87f799903f52092db32339f6e2a23f4095b1f28e238c27ddf8df75f3b674cff36c1f066595df8d1b7c6147bc67b18f6373e4473eea7e1fad2355c3eed46c65fec6ddcebce678c2859e872d9aabcfaedeeac39d858f492a57026e21d27722104047dcb82c78d7fb9422433d5f62a5ecae17df2c4e1bdfc5f24d5e27fdb7b9345468c74153a835a7fb1a936e1c70c69ac09bc3a81d74c78e9c2e8fb5fe31a954ac7519d728b4610d2fedec601cf273f0e887ccdea9932539891c2df288e5be580aa36a185c489cb4a04e4f5cafb1bc742cc684f138140b0d8bd719b8064d95dd8b37881c1713bdcb4c7f195e3b5d4448135925f2e8ad69a6552c88595b295e358a81249bb37c95674bd63858664f2e9957e0d8fb9fbeb07ee20a1033205f70db3161ab446893142e491d010578d4aa696d84195fd60b2fc502cce17fab7174c13f88d5fc2d3f540c52c766ffda8e34139c5a9cce361cc30b86a19376878d337150d7d8fdd6fbab3782f143ba50782d8ff9fef365b7a1c9fb94d1aa6f7083436aa2b438411f2a0d6e98864183fd806b03732f30165bc4a1930a55bcc1297ff734d1f261b4d6fa4b75ad78bbb9c8e6c8c31bf91fe432f9d86f4468a8c0388e8272db903c13de7ee309d984b63311842ffa527a76e14eb6454df39257a72c8d439a2883705606c7ffb3969a6632b358ac168d8105cdf2cfd79ade17608aad8e5502b6405dce6eca1ab0db116241108137124da9528d0dc59e7332ba166fdb08ec93dea1709cfe996256812a45eea14648973d136564891994ff95658dba49af8cfbffce1019171444dd7ffdc3f1d91f1c73893fef293150808634922e447d65381e1d1c1ddc1750223c71fc0420e2f209713d7ffe0b2651eea35ae645a602a69a02d2a0246987dc0ea9e0796d50f5a75c74522fe049cf2022a2fea705d40125ea503f93bcdd067a4835f809ea18f0b407b79c14ce66adb172997dcc89042c1d95b6c6713fdd9da86378c6395ff8667c420bbfe7d202a8f580a0ed7dac994e5f577f89daa82b3e8977d883e3f5968642521646fb2a59452a62465e306cf0695069984239ab44d94d9c04a260189246d33e32fb37fd9a168a31d760435f8bc66d88076f4134f20bd6670255142821714ec5318597acd9080a8a12676482a882cbd6648c0154742e8f4a8b723b6e08ad36b86c6c2c5bb8262a28226afe94523a5ed69386774523adbf51ad5cb8c0971e60369a602be719f0ca91c9deb0c2a55f743613583822ad35765fa37b4a7f7ab17cea0405f47e71bf5e3cc07d20c55ae5e9cf9d8c9d4734195e5d7eea4edb64d7477a7d3e9c779dd3b7e774771230f304c8eb31e50af1e4fd489294d9ac8bff2f1952c7b09068321796d3e420e69b2bf58724c801c462bd99b58e42c0a702b3c32b91cca3e8596ec4e0511d9a9a86287ec0f56e194fd5d5644c9fe383957fcc8fe348c64ff1a3a647f1b2c1091fd5bb88289ecefc208b27f0c2df01f2491bd0b51f62e3fc871068341f626594e2a64c6308e1dbbf3f41449420329624760699f12e4b0ea7288dd3d86684b103700316488d8cb7bb27f0c9c12fa66be228de5abfaf8a9ea851dcb572ae5fb9fb9148f57ea6bec681d973aca6beea7b476a0117664aff88272bf99c0f1957ad06bee43d169283adaa7be1d9dd7dc1b76d4c7173704c7577f333adaf76bdf1f5f33f5c369f07e0e98ef0d710e3bca7dbce6deef068dc99e2f9072fbfa3b523534afee98e9fa3afde9d44f7d3b766c92d33418a61f8e30fcbbc6f89802727ede9eb4c17ca409a32a95dae426a5b5dad5eea5a9d4bb787939ec4205c355ef8617c6eb7cb56ba96a467c9527f3a6920f3343be7042cc336e83f2b7df64ca4d8830e08faff266c4df5ab57a18956aa5fa95ea739a46f4684418f1b187820a7f54c1bc6cc2a1fd9ca6d1362f9805f395058b5a5bb45ab45a31316f3d167fbdd66b5e8b180fa785082c3ce6a5d7facd6301be880dc6b87b6b7aade7bc985779feab96d7c58437cbec3131ee2c5a2c5aad178f6b303ef658318fbdd6bf782c1cc6bb5c83ed22c618e35bef72b8d5a07b208ea70aefe6752a46ffb5fe777a37ca602131918e484cc10442ee98a7942e5dce29c39952ba7429e5b71083cc17689be92f5d3428651038eca49596309a8451a4314a4937f9b473d8b9bb4a4afa32de5820d6f477f446a35fe7351fc640642115995eea1473be3d8243976582c3b864e3eff7f6ebb42f7acdbdf373b93c32d9d0983417f53a835c1513ca2817c0b34871a6a325bf22ab22a99111a514068351180c466130d86af5350c0683b96b4d46525a95fcd952e01fd8a74418fd9dfc8eebb6ce764a48dc976acf08661461f80fb1a6df8d5c35359ee7466e34fda9c1399f1a746a703abd20677f0d8b71c96f566ee44646b5d65addc88d6aa5e05ced20436332329d0b409b681155a2326a851ac974b17bbb216a203885fa5e3689fd30044ba4affb2d163591b9aeee4e4a690c9d423835506ab05f0ad214c2b8ebfe41d0e5c2c1793a1a8af54ec3acf4cd64a24d54fa663e2db58d4c48ab1cf5cd8c925129d4871ab560f21b1a7bf29b7e9a517e139bfaf80d0dea9a7ecb9441f8544f5a140dba325562b28c17f3d67593169ecc170895f99c6ee1c5dcc9c87853a8c12a4a4652869062e12cca3d9b6c57f08e7c19190e9cd0f9847b31eeba7f50c8851c0747769ecc3d83eea5ea04cf31bfc99e8194f96d4aa439e7acf488225dd50cfbf7a6b494a66d1cb752ad542a16c6302f14e9e553a928e72a8645abc5cbd91d5d42632debba4e729151122a26b9d9fd04c3cce11492f99cdeac94321e0c53e6658b6f2669b0a51543329dcc47f47dec9aeebbfb5ad0ee9b4233466353c86bba7bef43d77f08b68b0f45689b2eca98f9f6bed005fe17823f802ffc4e005fd8812014804f68a66d0080af9ffaa99f525a707fff7dfde435fd4ffdd47d94a96b4147438c6cf1392d85fcddbb2c3f15fae6fbfe110220f3fd3925b40d8b6fc5c0bc60d64ac56d29eddaa0eefb5d441920c87c18828c4c0172d3188dc9c87c5e8cae1121a7041a2ad4d069d0c60558d0400b381acc11c30ec9e31b06952ca3034da6e91324afc0a2fa473ed92b8940a608f68df1fab56d35c0315cdf60c3305351e03046b52cd67403c91a88ac7bc8e41432c92493c958ac05b125624fc4a48869f1412cb67a15b752b19834a7d853cca93ecc8792493a51bad18d6ef437eab365ed9dbe23996493fb38cc61527b91421b8d390ed1465a4b29a5f4a36a7a6b5a7be7a5d6cee96fe9a4ad77db8a0d4927fb49a61813fd2efef06699ad62edb5765e2a0d762bc99c5e360dcb58df0c276b9bd5dba856dcdba83ea218eedbd1607fcc1723b8592f944de47ed944bc913109456e6badbdd67b1c61bc4423a42492576ce41b1365b8cccaacffb09acbfc876cd324130667f8cb2116f1a6658e695a51867d23628865538491c5082e4b27624d7fea93302f9b3e8b66a30517a44edf74927e89373206513261c9842513964c5534ede54546463261c9842513c62d14714ed772880d61845339ce8a040104d31c67458c8a3441f20765f62f212abbfbac8853767777f7f19991261ea36dda48f618e34b9a76f1b21fc8afc859441597de102cb8a158afb53ac5ae41254046b845739c0111c921fe24ba253e291e6c739c01f5b001b3c8714624cb13fc04be8838cd88007533202c9811f9e1618b344eedd44ecd423f0d16fc06a4ef04be919185a14e12e4e404caaea25b5ed900f929a01790fdc3d44718546016da86df5ca3abc416696ca5b652a719bfc3d7567a7372e2130e630b39342e643299ac3bae63bb620b346432598e0cb00f39ca3ea428fb97d03566419ee6fc9cb66a8a3881380149253251c065d4b9005f58b194c34e882c87b77301be98a9513f669d86bdb4c76dafb7c383f3aaef735f9af6dd1cbf9e0b0bc85195429422c78f6866fe8e287b79a0be07ecb499dedfcfff6ad89f1f0d62f623fb418af50a1c674262b39f3c132234ab0148a7612f2b7deecb12d9af7e8ec79027bd91a3f3fc74788e1f93a32a8503e4f8117960da4c6fefd2a5638c51e6d8a5cbabe6e84c543faa2af080578db389a6217f72d39fd2afb36faf5e905df20c0af6eb9f503f1e797afe9ba69ae15f47a95f2d7e8a9bdf9b6a46fdf0c6715255bf38046ed78bb6a97fadb5f7054d096d13f250cdf0ef0e81c3b9d55a6dabc13aad27a3af3ed3e8d257fef9d6608b34502e6e6e93dce64189b62ff7bd6c00d38d52bf9ccedc3e1943a03313503df736541ff736e2734237e253e6f1e2f1eaff42697ff376b6c73bdcbbc7fde01762547ec5a80095093cb27f8e736197339d21fb4f2f9c292c20dbdf2ab7594aa9bf9c7fa96afedd3c285ea9bb4fd54afb7474b6f7dad79aca906cd16fa0589d19c29ced3a120683695f0772df4df3a0cc39e59cd37a367ca0bc80936fe4f07c1fcc3c5eda6f518582bfe6ed68cf03e5059c9cc315405527f0d0bcf89a33e44e2126d7df2c27552b78f6bf9cabfcad27a1b875f74b57f7d3d173020db1c5b69952ca08a367c8fd5346908260669f3054cff4654c00fd483d66ebe9e8ecd257d67e2fb87f3caa6c2aa1c3eecd534905537691942e4cc995e2cce7e7e7ce2b835da5890453824da4b69112e75c92c2fefc0ea1df7a39e1edeec5ef4f0f95c3cf33d27aee647fbe8efdf9f2e7fcfbed507224af69eb465ed3fecda839c537a1bce6e955a7e010673e1d01207e28a38cb2e47e3fc211a18a4bc98dd3367e94619833c6f827c01100a11b69d93f37aa42e0f06617e78a4161354b5c8a62c14a0d9d2b1528d66409dc4f60e943dec4633e305c7d804418fdf1155f1516d5f125935f389168542c46a11af4894a3454a8404736eae430f7e910fa3518e0be5d5c30978b32e5f420b96250f1973f790d0d700866f0057582b110d531d9e819cafd17b89c8b2b51e61e0d1f1c46261b277c8679919e1fec278059eed0b11cb6522321f13c49e96e2a344041dd11cecd83c7e131025f88304344a977f110f883c8410e7142704bc72394fb5dc4d9a299f336e1f9deb9e882650a702bc7a42846aec6018bbe6ca73e7ddcfa1c33fb4ff942a41ecfbf3a11f8cfd75ce0ca3b187708fdad0f069a73ccec6ad008b582be88606c5d4e5691b840d029f7bfc02d9a1872366ef00a1c8245708873abb7965eab6b1a831d3ff00527ebd2e57b65b99feb5cbc68cd6e0a4ce4f3aff9cdf8c717d735fdf24bc2df5df41e60d7d15094fb5dd04898b3965e3860a12108a7c668e08850a57ea409ab2cf7bb70eff6979e471a23a6114693067b806b161cd658cc6ffce21ac39922d6f4f7b840727ffcdca716c9ed4d68548401e4353e70e872c5a8324bc58d3076cafd2d29a5cb64ac9bb4d11358463769b08dba4842316aa3063beca20843beaa0a305027e921201fdb0387977319856d34c6cf3fa77b8985065d4de029b8856f21faf20b71f452f6af071c33d1f59a23e8df57d3af86d7340d1c598e52ee2f017c2142ac3205877189a6c19c6f0311862c6ad9400baf81feac81a7814a012c46c5b05394fb775cce85dcb9efeeeeeeb552194eff680c0dc23a84fecd075ec252e0db029cb4edd08f34a185ea10faa7479b44e1b0976a14f8561ff9e4c414673b4159ae801e75931238742b0d32f5d27c21583a65f9d158cfaffa6c5670782f67a166128e56e4fe899beb3a847ef7300f70189568b40d101ce24a0587b85790a341f9499752ba9c91461a698c32c62f4718a1728e182254c6f84796dcdf722187dc7191e79c73ce49a5acb2ca2aa553aec1a6df0e17bc187234d87ff330180c067bf55f8ecaeb6493af4853afe06b450ea5500bcd7e58c9fdf2e7722e64904cd2200cf7372c875268467efc7ec1ecc751eecf097170a072bf08331f4cb95f40326b07ca7c49c33528ddc3c9e910faab0f707f370948c4da66e613947374e6c0ccf785042482b68d042492f826b91e8a012b169dacf9a53827dba7b6b845ce552ba432f72c2ff5305e8823c3bcc7be3926c63fe6b71815581f9b52fabd7830bff25432ef31bf8af9978ffe7de15dc5704662beb095698afb6ea45a8542eadb3ec7613c19012d73ac9cdeb667bd7c2b2fc491574f71a60f03f38538af564f653e26e60b6f5e3dcccb78b16b60727ce585f8edbf783a6486f956a1d099fb6eb07e7ba94a413eebb76dcb311ff385385a99f5f1575ec8436698e7bc1047667daba71ef730decb8bd799f342fce168e5e6388fe585db738047663db7459504625e3df5421c99fecae38ce04b9fe58532b35eaa4c603dc78a99ce90371cadbc8a1fe26865d547993da979610936421cf31545941b5890e5471cadac43661945941b9068d13039cc4210340bc10e172e332457aa9319122b332454aacc9b79f4d06508243bf450410daabc66d02ce84aab6703523eb2e7264207ccca7116a4840cab729c0529b96edb7ceefed37d67bb1fb709ce39dbdda3ecbe6d13eff4761f366febf24beecb80dcd606dc1f766fa96b9df65dcaed473fff2c0f38befc6e17482e461bc59e00cb9f7384ec1a5001979f14444901971dbcfcc8100e5ad2e5fb914badb54136083d0192cd8e0811440211a820593dda11e2a469c1ab1c67427400c35c8eb321301739ce8650b96d13630d5b8c37d3bb238ea731e12897a834c64ae737e79c4c647cf9040c0dcb3165adc06197539f929ddfd4ff54674b050e3bedfe8ebf0cfeb67e3331f5cdc4fb3ada3713ffb74fc7676674e8dba76fdffedd9cb354609f899f43e619ee75fcb557bdccd79b892f0394ed65d0de5f0628aa97c15f7bebcdc46f86fb26a0bdbf8ef6da3e9dfbf36598df4cfcba0653ff5e93ba49f0cc36b3d9af80f6f693018a8eff7d19e66b5f812b8347fb399dd268526e444abafc1475e9d990a9f72da5d54fa55ea66e2a95d2a4949a76a50d8f0d52269e6d5b2bad6c95b5d6566b6db5d5de5b89b4a9cdfaf33d8834ece9092a2a0b171c115c2e97cbe5f23a031c4a27a72b5cc3645084d25a69d394d6da6a6b37fd681a74a27bb913d0c8a94fcc0904d40bd0e58ac1020e1198aae02c315d61727a6aba52c3615e23050ee5926bc90a4d0dbf690eca7530299d1d063f46259db6e122d88f3bbff958d3ef8a35fd39b1a669c408f6c7a7de8c60831dba600297e7ccb2b9698349e7acb3d29b1290b8a0ce5a69a53395fa86584ae9bc6d299d97d279add53ea7357a3f19415a6b9db5c250bb5649bf54ea16892f00c2658b3457d3342f460ce42ff8016a3a29b5d4cee62a6e75328257de4ff96bde8b06dd42e1796350a99af640279db3ce4aa50a052f7f3408531d9dc20ade93ee40b6942d650467d872465fc98f667ae6809c09fb517696d97a32d674c823cbb99adfac02045fd8d0400c97fb27914339579a22088220088260097d83a36b5a4871c1a104028372daa68d906c7cc957df17909fa0ce5a6db5d39de87eab4c28a16b8260d7d13101b53bc2f09ac2fc3a82f26bf881dcef2bcc3c75749e76867cef77bd126d1101f8fefced63cbfb7dbffe54ea5be17eb36bfce76fae49a93362dceffef8d568cfc6fdbe7fa35fc786fdf85e3f8c317efcf8c518e3176a9e8d1a9e4e83eeeda95c43a76dbaafad54c6a650343fe99c7556ea4430fd105445c0bb749111940fba54ad3033d521e583f49d7e3050f9ada333a5a0fc886c7f2e1ab45d6e4dda24e90cedcbbff667ca8bd6a6beed6fc8dfbe9cbe77bbdb17a67efb2de5dd0653184096bfc9adc319da6fd07dc9868efbfb6f3db0cc711674253a4d28b6e89d4383068d06738830955fe57b4d8edfdc973f8dae414d4a6b4260f931c6ce7b075b9cd65a6b5dbb518b9aa6691f654819f23ba11fa4af79efc5a06990d2f9e18e32e4071361d0a738170afe8cde6ba4ec08ed08cb974bf74923f9cdea27de721c3041d9d2c5f2bae003439471bf0e1261cc9f0d88b9013a6ebe7e7ffebd1877ddbf0bf3f11205fa259766388c5052708e395186849a50733a5467b944ac99ffc495428b0f64b24b9e3fefb7f2fad52a133ad584fd97883739f2893ca514794a2d79fa4076996fbf65f373fca67db82f0471ea0b3bd994c160fcd275f86708e6d9d709f697319f7b31eebaf0b3434d3be7ab3ead593a6cf29b4a3abbbbbbbbbbe99438dd51c6082312d50fb70bce68db7a1342f6cb1861c418dda738c2f26998c0f2dd9d896e0e1f61198f70f4904776ffb4a3ade7cf4b03d2c882dcaf824c40bffd2b91b254cdb63d670335f8d36007758d6c40038909e81fca9d24770d11467f1883ca598ee83b19fcd235c49b1a5ed34fba1d300eb98fe48e4baf1de1cb75da3b5157e7bc9a23e5f9b58f10d87db60c36210b797238fa9cb3bf0dfa6de11b60ff105329999c9e6a74dfd9fdddebd278c0fd2196b84e9194840606c831298994bce59824821bc429794aee974d7797b2dbbd28cbf762dc75ff12e7933dc0bba9d016a30c4e6e31762ac6a9d13be79cf7dadc5d6b8c96de19634a15c1f8a14fefeeee4e75fcc87131725b4ab5d27e6c5569fb6184b845890cca0992e490b4a44920828e074c734cd221966d8e493adc90c3cf0f6a396c252da92269c90df2cc314907240dc5669570fc686364f10b652c470fc49b2b7b8412882c22837b105a385c88a10a0e631515da45065ba4300c1f70f585d87e5783f9b6ad4a4eb69eaa66b462627e6b0e009c101cf3302f732b26be7cb13b103cd9043789eff1575f7c15f7859d1795e3b7f0522d84f77e2f3a16fd5106d3d747480f32a71805a8d65a7f2a85b2c9706004a9674ad1ddd1acb5b687c8155b69adb5d621a35c6b91113d954913932b4cb230e152b4c5feb04548b528053f48d0596b2d0ea4501c50a138a8d279907791141f5b64a4061cfc07a65a7f2ccf9373f56f4d1201ec064b7a70a5a7b65a0782c16037586badb5d65aab94e30c4b51b65629b76610904b8d6e10fff11169f019c259daa4c84c494a464912e2e106bd43effc19da4a7003912d51804c12f060e98626120871a59f08318205b4569e1ea491eaa4c80c9cfc8d4d58d13571e7fe744dccafa6a0ae8954bb3e683f9e64c744c99091242072e8c109959f1410469292c8d8121122382c4141101c5c60450f4b524f8224500ff5b8a60d9147d37ea60f260f45a0201981acd65a9538759c2d61e4949b849819823bdcc21153180ca181433af223c99cb16508cc49d4521452bac9131f5a8023846ad87162b20509510de248e5b1622d8f12b247096e09e10eb730ee8981bd4c463018ac0667ca7176c315a69cd3972af1209f76d15b6bad55cb9096222d475aa468a1a2a50abdf7de7b796610ac06d12d164a085c6083ca938467e8bbe2230805434ff0a0a899f040c1f4f8e0490579f069fe7dfa2795ea09327f98d88230f2c4906664c309b02801c1603020b3268e94609aa2c801961524e1840f1e9a92b09a9e006d2006c5088e8200720410434d57609a7ae0c3cf265e136f0de2d4566badb53607a86c2db54a889440e189199204162750a45851da414994a9c4044a7a6a50ef1014240754269b88b2821985053d51846a8fadb5569e1e9e564a29a594524ae996a02d49b60c6d29da72b4458a755d118406096a81a5578b4f7eb42741da9324da9321ed4911d8e347fc080beb471428d58f4ab4d3a351c1d14044094d064288681acfbbb82334e9831126394858adb5c2724caa212ad7aa439427fd5401a4e9e50f214ac28f18ae4152a99f22330b97974eb8b55919722209cc09143cbd24ca0faa2829f8c11d6e612c8988a2c42a0a14427ac425b01004a9e20755f82084a5634b7cb62547863c8f65723565e212a9b556adca965244acb59647d3acb5f62787255ca5adb5d65a6b8d331c9ae45a976a8541ae35c80919955c8ab81c7191c2854ac7a5ca73b10272697271b98223cb39adedc005b9ff0d82f7c3a7b99fd37fff12b992e5a7284916840a5ac9153edc20a9ea4145aced1952833b8110aab5d61f9fa73018acc8d5a6f5e2ac8aa86cad4fbee286d48e099608e29942258919f408aee0994a8e0401b161a7081f9a9c44b18329af9a43ae4943902c2da9b5d69e221e4db33f7f7dc4702b5683e00eb730f61f1f9d8494242b4249aa28eac7905a1f271d51922b9657ddc1e5aa9a8d4418754d44ba32acd42d750d114cd6ba6c27c9768b92adb573ce994ad154ea65882a8ad0010d3ae860031c8a80829b02148254aae75d36e825ad0111489a882d6189c190082a12476ab0d6da1e25a851066ad8218912a08089d9911b9c9833f0f199d10c8956b16132098aca1281b8900064051ee23f3ba92422513f40d45aebcb8993a6d920073f94e8d9c10f3f50f981075754912474a4847624032147541099545c97b5d692d06389526d7683a452d6ce2b880449a59400f90eb3569e2a61508411b4882a3628516bad4b7a40a288abb3993c0f3ecd7f4f1427f6e75d33eadb862072e08e68203242103cf608071e2baeb63fed0c891108596bed4ea4f20352cfd3bcb5d6fec45aa7b5d6da0727fe5aa7b551aec8f666dbf3ffae1b05eb76dadb798bf02902886a178b1357fc40074a3ab001d1cb86200821b5881e82a45223142164a730e1015a52a44892219f453e1f18e2490e6cb8210753f8d0488ea0454b426aadb53e71f29a98356d89a229b9ce6c18eaa14f7a484282832531e9021a688f3a5b8acad6f6a84b3e896d4703900042f69acfe345d3a0cc91ce4efacda4f271220c700a9e0dca1a7c629baf3698f932672bcfc9627d217d0e02aca7de7663f592ce8f89613d0c65fd0beb653c168b8bbf9acf627eebb74d72b4f5f3af2a022c3ec40fc2cf2f6cf17785f9b556cfda565e65b15e359fc5e47e3e55adc0fa15f737c7191a3173dfeae7af7efef62f5ec8a980ffe59de585abdf3efa75c63c4baa22407f7e332f2c6fe6e5b967c17c78f30ae6675ebe6dfb15eb372fc49127f71687ac8ff9382198f5e168e1dfbe1bf85fbe1baa677d4e73def4c2d587a395f1d38f15bb2f8767164f9ff585207cb3c597c373eb298b2f94b9f539ddf2c219f264792bd664cdd5b35af329a79a91fa39039cd9a8b44c996b62e9109108000010003316000020100a86c341a1601a2792307e14000d679e4872461d4e83a1204571140241100310030c20c4184200400a2969b203cb2df230bf20a0e8dd74b61e52c2672ed7103a356865ff89b79adf8bd8a924cbf0d63935490b230e79f2d4d9156f32a51e0e91dc570498909e884c184ad5ad495b514a0cc3b8ac2aa2a4d9d425e0b0630b10525d96622b2c50053773aef3a8fc1bc591525e852f57c0ed5051b7c33e8aebe91fb3872789514f9e37b7685af457368893165f16c70a97d96c6ae7e96f2a14a87863a6a981f7b4877732ace66a61980ab78c3e1053401755a938233bd85d1b9b830e6db25d686447c03d22c656e1b40f82cee495e2544ee567b533d4e25fd3e82d191cd36ce3837843cf90fc2df84c760fd2f1826350fc996abea5a42071c402809193c00d8624b97e6f0bc955ec596edf5c3958b5e4e62b3819c8f38ea5191390147951a5d7400a1691eb7b08e1aef54beff4e284a894652dadb1827c585b0386e94e42be6aef3ef57ed0be853d04e694065ba98744e73b4e5a7bd7083325f1d357c784cec047058d8be07b207f4474994744347c4761db231a4b7096aab8725140a9825936a7f3083f680ade3807aa0c052f80f26a84ca200a57ce68af2e13fba6536a43c5fbb16022bf3aba224ecf4e43a436f5272e6a21280be46b4f1873528aac73f7b1a7918ba479e560cc9013d0dea8527578eea5d78121fa14e7fe8900e4294283d995aa6c9ed7b698034dbe6b4d4b96be119e826d57770b5f909a7bb5aa27f682b559ce570c22cbf513e17f8ceba1c28e0a54e610e1475a8d14a930bb63d4ee5c5093c6dbe4dd5d9723d21b124782bfbbb10b9afdd291491d77a58e62a42a873155b53b019f26bad21d00bfec9f0dee84918fd247a4f375fef87ab409b3eaec668dc409fb84e01a848af8be06b2fae6f6830bee8794d5eaa98c572b3dae56737f93e269a8b2547dba8f7d60644cbe31ce8fca93b96ea0ec9aa65d975b6eb6b4ccd39d45f19825e2bc03870033c93758b203da5423374a9695715106e44eb02b13f165b60e77076817e1d1343a8451391bce996e0c4b7968180134a77086c5080daac7b3182647254b4f08df7dc719f3820e46d3d1ceb8048d99b6b2c3305f7913a039b399f6b291571b7dda7287229a6797cac88ef1bb723795ee96083a1a2e1ee417b13db542249e719e863e701817d23ee2a0177d7507a586da054636aa5e34996151d37ae33c747220882dcd202de62ea8cd942e8d377e6c0751844d264fdb5f58dc6e3c0cba13437c782cde8081306b2b4846312707fb286c744266c099dd451a1032a50fafc9acf80011b37168853060e994e5d5c347c991b0ced136409d9326e5c906a915c289e8020280b44ead80e258b120a71de565e475e579df9041f41af7ab1111985cda75551f13274e2c9551e8c425d3e77ee3d3a646a5b0607558fcf9a88f32763c9807f49924d1284b86b896d56f1568b5213804c02b5196fde097b1a12da79282ca1a1ca1f885217377eadcf58360bb0d74ea70df182cfbd0f57f17455750bc42611cd22c492f17bf8bd8a8820a9c752cfc6ad41a1b197494c57cfb67d6b3656a0cd964c2b2ef61d9feca9ad99e780f4db0f439294576936f6bb24ba05263c1853a96f039802e892602aa7878be1cc7f583724c2cea2d8dc9f38e7e7d769624763b174a4476a60f9960540d833d155922d8ce84bcaf8dc73e72af03314847dae77b37251ab08130580a0a57d3f44158aaac3b421c890abd781790f0ac0c16a88e5eb7c472119376f1bd850e701b82208f58ca395f586d45e7d406eb71e1f9b1d9870aa480abd4314dcb79a55a93ca383f055a9cfb2fa5947b8268402b75ac68e58a75eb9d4ad0b5a7678a4c5136db1dc4feaca335b7db841099f5666b653cf94c44d49c5e08d976dd62ec2756706b6a9af13a0a6a47dd67df8d5718db2027a0e341f4fb48fcb336d6605504755666f3d24094386a3ea435ccb95daaf408603cdb06ad74d798007fb6c3ebef26c82b24ea8752a3658d6656ed5a6e224634b9a4a2d72d3b52a8878885c1afdb8d83d6e7b07b5c4036006179f84b342416d33e4d7ffc66c6bf36c8f974ff56f49c55506bc22a8f21251d6f7859413fc05b83867c3f22372ac078d0cf9251226ec25f0d26f50b875d5a935392ad674ab2a6b3a4bdaae302b1564e7414cb9eae5487c6273746d71033927cad125d915f84963b94e5e8db9aa6af380e966d6aa54ea3933c3f24e9298d9bb46b931bb024ab258699c16ef503bc35d1750e2e3044a8315e8f51fd2429d2f6ceba480d69c2ada104a88504a88099a58285faae6c0275254f98fe79c011b65c28b6336f74b55d1dc7c677a267a9cd2b24380018889d7c9b7b3a01d0b319a1d712aca1043a265e6a15f96ec9c3a6ae7a77acf5d636403c373d25b6bd86340c5e1828b4007fa799d9977d6093017fcdc3a6ed50cf0984ae786c3f4eacef451caa150bc6097ec72e3b7f408d38b41387f0573a4b4ef453435b0d27bd8d554c7f477fd7aee95a5d765a6a0074e01eb273b5b6e2e4c05be3ffe27e40d630213a3bdcabf698e9d5e44028eb6c53e42af64dee516b244bf73f104aa4443bda35b4f5e03de782c0c01a042962b4bc1269e85f809d6ddb3980662813a7ac1e4ab55bdf1c6847dd9fb11cadfb45ead4125493325eb49048e5a4e43232cf5446f8caff7854f1af94738c9733689d94525003fc1d514a8412c2b21f88d1fe7f9545b89014f6a3332ec2873a8b7aa680504e1fed87a24a82861531783a5f7a5eb960504692d69b90f2854826e9695033e222d35edddbbc0a305f931840baf2ad504224215bf2d7ee6d4c67bd8bc59bf334f33ce9fdd35668c4607250cc944cb1d28328d16c4aa4dc536637f88c831ea244857755c4a7e67dfbf54b3f9c7d5dc967641b4bb8f125b6b494067108fa5c985a31009230d3782ab0ccef73fa8475a5bb9196962479974fb86f8af7e9dea9463f77a771e7732180f94f82f1615cf4cc276229dd8b21572dfc7816d8054387020a5f3a83297c7811945a7722978c5ca80bac715ebd563621ed2a60b2be652dab542e5365e3c98a1083f15a32437961e2f3ea87ce863e2a35643da33479605091a34f2988fca476cfd95b732e7c644695cc90e5fe8fac42cb3c5883840b30940de30ebafdb0b8b7afddc4fe5b4b4a11b5c8af1e91fa521c034828c2a705b2c8c823cd964034827f26443e77e7f1a8569d092cdc2e46a921c9ebf809dd8efbbe5ded8c08bc950208a14c5c8b24d869eca351d6e4cab34813baaa0dea2677ae740242a18489c90f6b497064b0987a442be98d51d03ad6b76364e55f484232725e54667b838f7ce49fa19653fbca6ff559ce0e615b2a3209ad64014d9bb78996a37c53fedefae627acd60b98ab9c2b9c8955fc4ac6da2ea9419ac9ede151dbdc4ef4da57cfb25dd3bfdacae7a04ef64ccc31447f5e333410dec385c1eab754827e6c31fe2641c99002df74dc5080acaff04b9b41a8898404760507cd270c8d4bd453a133cfb2622f85ba056a10f5fd026625a2d6b172eb130a7cf6b58058c0881790d2c016804d7d69afa1366c2bb6b6abfde66352862763e4930546d6ffe3fb9832a92db42211e31b6b695840b282718277c2e1c55625c92c8956e0991ad5f614bea3e2853c23423d9e31a74493702b16269210dc0a9bba21c3de964cf61c3f511d4ad4378089915ea693d70d71e44020a65b3d0dceceb7e6d4c7b2a171ae5ea593dc32defcf022a3b2eb543a9f95f0d705c0c8bd26192813b321920e0af9d165bfaef03563a30fc753c3e6701c9b9f8c5f83771dd19866c30cf8ccd95e11cce92e38a45b4a7446c9c481b456a94d12f09e304563daa647241065808a04f0c1242fa86df5d1a70609508da06b5c3efa09e75a6442146b401e65de29f2b88c3623dbf54345db30d676123c4e8a3e3cde56d918cdb674727ac45f6b4480377ecd660a40a7a943540418dbf2fae7a74ca53274b583c02e4010a579d20239d06d654d4a32fa9add1e6e30b53d3fcf7e111035a440b94911cb54c7be1d323425f1835288c9fb2b8eb9a5eed58953ca86c2c4c0078a60f86d14ad7f5b58a897415a82f2da81a0037aaab6f23099ec7a949934256773bfc52920d35e5f1cf11482aedf8e4c37e597dcef90dad17375fd12fc5901fc505dde0b4d63ad46979856c81a8969dd36afce2a16885b31b44e4515b457242668c9081e22e199cc5ba2ba753a4fff565004d3b8c79d98fcc56ee76931be4e7a5429335afb94220da700bbf909fcffee8424ee23ba26b4a6ad8731060ac2b95a311753947b8eeafaae7fdbfe3e9699159800ada4c2fe0d36d4a6e1497961072cf0562e5e20cd8446bf26a60ae7dac97b1801dc1467236d0733e1da12752e4cdbf8bd0b0dbc0d433ab443c9adc2f5abe08604a43afe1ae4d7adf986adae8899aab97f0be0f5967637d68a7a242b4c2441410b0340e3c9de46d24baee89a664f8ec9287ee3c40e25cbc0e46b18bd3476f2f79efd56b175dea6a208a2620e1ba72dd677015111c92e8c2904a608bc22938a15ffee1de38e29a6da93e08b87c28557297a1426bf5fd89975eab3392d52d8cb6b7d78a4fa7d8282c8e5f92ef7ff806fee00141c1f0349a3039d808d154a26536a59a8ef57bbfa5e947ef4ae40555358561a447b0738c026d466fa48e0da8259aea2a0810d332469bf1ee308d382c48b3ff333195f047a46aaa1512ec6269c412f1cb4296a78d522c7b1a21657313e94931f1099086978400be706b0bd630afb767949b7f17a10eb358a541f92c5cded4512eff4a100a6938cd60da712ae5f8e680f72e5b86e19a3d21e3634340339fd6d418e76acad9fcac8065c294eaae571c089e3ea8c6760e0489ff58aece20c7da66b308e0296a8a61b2f03418cce8c5748170f4f2fa96944ff79c49288dcf80f2355f43ca4b01c4e12dcb0f4fca630f0904c1bfc40d74302db737248b72ef1940d97bd9832612c2e6e11d790fd3382c0060f09705803160a6dce40f26c99a9d5e7562ddbc8be45025d7d4a30266514cd901445820de0be17798395651244bd086170f98ba5e2fc991f8295342a263640948a53de8a85c31d499232de0656236d3e3a71288328fa51302ee24f7118ba4f1c0788caf42d3e4956ea2d400e3395df867a384a813897118b8dbf0ebb125a8d1904a1d0455ccf84c7a63f84a9769f5ef234c6b320ae5ea871c4165769a1a950cbb64f29c75e272a3ea35c628594cb0c767eb165a53c58a7caf2cfb2d52ae12282a6c25f9bc99be8a582d3f635e45695e4320295d7aef2ed1a3e5e2b861140644890f1f02877fad44d0c0be65861213fa14e71f1709dbc6ea30e215295095db40cbe450cb31ff1711ae06a5d14785de68d0892d24d4ed131a1e5f42e7fb59aefa2e8a9e84c553c8bdc7163ad224388e4070dbedd50706ebd1ee8cf9044edcf00c9ca68f6e9df7ae7813160aeab8c67e2f76164ef5897ca5e67723371422f0434f8a2756679a51c2c46f065ed9c8c074b707efa75296670354c7a6ac0550cebaed88cef4950d0255250f24b1be3509bc9992d760c750d944a7065216ac0b0340558b6a82a3f2b1bd7045c55b9e71b35919542bd0ce5fa83dcb080d657746dc9763282f8c2bd22065a49cd2046ba4ebae7000e18eb592fd4b5ea0e6d13aa82270bbcee4ffc2262d0994efff85a76e023416378fe487d3d40aa40740d3262fe8a39113138d3005471bb27ec5eec7e440c3a872976330004638a5c42d21c341010b8db5571f94798ed1261850048e8ccb9fb8a32911100b08e5439e78540a4e5f448bfe03053a06becfb3aaeba0fd18c3c3af18f9c14867541181f3be8251c296801bd020c838e311e66a0afcb7bce4270a471af7f10f5aed4565e9f1506479cb384d273fe97480417525577005d5e747bdc0431282d0e21834ef164543c8dcab22a05ba66d512310df648a9fd4b1a5e30b1c24075d46bebfc0cc3352cc1c3dd008b968619f9d94a0bae0b5ea4c44b4e17eb16b12aa4493593bc776add2d99536a15f6e34b12b52b312735c7943cf52dca7e8827e3cd365ecdff3a45207b9426c48dde3a08888f5033bf6fb4165b600ae5dd5401500f9b9b2bdaa15d3849755e4089f8a2fd7ebb670502f845ae5a12ca0daeb6025a592cd7a76070a12315fe86888181a089978221f00dcb249a5c3a9e4ad17b824343cd8921561a8fd84053ae300d958ad6aaa08d3bfd63e7496bea88cc188084ceba885d865697f3cf8adc8d7d778116fa1d2c396f10f72b5da0dda8b72eebd56dfb899a71310efa195d7b3d72e6e75ac5255b3ae76f80bb8fb4d8e329b801b5405b596cbb442fe8633f1a9d6577459b17276ed086f8a9874a5d26ab2b64477bd10f47684a1f68efa77ed970577aef1fcffa4ab182e397fa378b571cae6070028602f396c15a00133aa70428de2ad0d18828e9165dd4bfdd73f1c82301ef697af32b145cd52f48dfbca0d04336ad694119b61bf65ce98d5d38fdc92e04e272fa5cf7950babd4f85361205088e643149f6e387638ef4bf78917c23b518a33e8dc7cd34f20dc68d0f4e2d8cfbd3db37ee0c3863cb9d699bcca1e6bcc3e3f1b2fb4865957d7b39a314c8924509517b3b740479a5f9b243fcc292545b138ec2e1a247433a87533c0c095fd1e524fa4070cc7a1d75c669c6aa3261809a03e5eed266a1b00fb60b029cb5c80a47ba70e38ea8aa025897241d59cd33e9a13eb4cfee83a3aedf54a63e59048bc0dda8884d68d2dbd86074c0b4ee6af18bc7cc326da3857527bcea59d871f00d76b7758b9550e1924eeb94d544f55f487fed649c39934a85df02402551401722fc954fae1376a8849d8106d2b966c3ceca6044d06a66078d8291462d2e43b2f5bf25c1cc81d23e85add0d3549d28ad941ca45dbcf24a8a8498c2c4bb0548e0db4dcdd5af2336f610da5fcea592b5661ba2125cbb6be4a7598fc3640f1c11974fb4f29bc5f7920b0fa02602e5d66ca4244b07a63a68f547b32141a60442e0051018153bc10aba1ab9b7cce41fda94a9a55ea3bfd226c35344e357b989f3d01203e4da84fa690b5b0b2da4af7e109c4e9d1fdfc4115f661313d6e1f94606d29ff0ed396bf09f83c2a8cceb10e81140ae32496e7dadd9be942b5c288b73066eb966945a633ccb1bcca0c66a977097e050f3e2a5a376fcd5dd54d759174aa94c2cc330de804f703ae6e3af0d01ca4bb000bc2941e2cba7d19a3c11d09baa6a6f941a136a37204891f8034288fee974145e196d0731535c715614069eaeef02209b22c32679c0c3571b6279b4d12727fa100d482b22499b40b7c22ead2ec00af35718dc40dc80e537aa4a309952b5d29a37ac297e74d4498830a1cdc72b4450813b1c2c71da6ba48f78bdb858aa570e3702e738861d515dbc6ce494b3a5c968a22d76144515b287c89958258afba8ba094d83c5243627f6b421d18e75831943a3d9c740947ffbb1021de4c82a8d6462c3d72f1b03b84c751181e543fdd2d41ab95bcccdf4a0e55e00c4de0c64e3ffab4ee466a3becb39295a947d7d73b77d2f4d6ab3768d62e17586bd2793f69bd1ac65ff5e39ca7d57af9e824e787f7d69ad04eed513967976073dceb6dbd3677246321b5d7c9297ebe24ad977e4316eb6eadd7acbca5dfd638f679d38dcf758a3493942cec2f2b3369151dbcd2fd66af85048f87a03f1d370dd092a63644be9a19bbc9377fc47119c888b1c68356440c37eee478ef15cdc2f6ca57b42f22ce47e491b44933bdedbcf97d253576db506ae21da0326c674ff0ad1eb3989f6d58212fbd14a5f7368b643bade76a1f807bcee4b3d5030bc64499ddab87c318a905eb5d734a00955528ba465d82023a10a2e2f185ab506410b285c614f08af1149711ad6a905cdf0bb931f634f0b57794f81e9b13273817feaf940a405e909dda7cd09de884d62170838df2bf412260b0a0187bbeb43a7a6d852944c11c50ee5f2f186ca866d5ba3ce4bc91ea159869332ddecd519e7d3d8a8b724db764927186c28198f93fe4cbf6a78549f54de9818b3ebe456e000ed64b19559c291362f48090984fc864445a46948c66a0a7a7efdd0a990964b040697c2c8d85439f9c0dd5326324459fae2e06e322bff9f190dc5ee1416ef1b032dfc8d1b968021efe26e19997d62d7a60a1656e969e30063f88b37abaec054604db40447b614335d884717f81318722430d20e65a6e5f9f3cb20e149383ec96b2165e8c25a4cc3967fab9703f80fb1c23887e1aecb634e07625c1e565002222864184713a78b6848305c913204cf67a8bf7d460dd1dc8e4b4e7f3058886a4296e6d8d46ed658ee35c2175c1d1f4e2bbf624a6679011c4b84d3daf15da02f5db75ede7394b458afadd9e031870769f1b46b8c0d18a344622934161837e7293dccc92f6facf7db9690cec9876e7b3fcfa37156320a4e39d8f86d97273e70422aa1c7a1ca45d7b3756bcf9fd87ba804e346b9d38a49b81825421d8e948f625059b445d8d2da2e14cb7d5d9d5db777c2e547ad2f7520ba492fea0c1b354cc887c1bd16994358676af4eda572cb2d21ee9cda14a4a0f7e2d92171eb0fa396a42f186e29b0bb401f21aeb79c54e060e6898bc3b3b152c12e9f5b86ec8b3f0a50e771171c7f1b13583789110be5f28edbe9a7a25b6007bd2f2257b20296b5e990fbd5ad7099bb915909dec8faa8b0a8964e594db687dd80b3a41bf930fb0eae37d51ac7a4f9e98d698c5a89a0dc88e8d448532ae986c9ff9ef0e82220e3f13210b9e91ad63306c9a8f65747d6702923a7253dd316e56e381b390b18aa26cb1f885bb7b98a731e2cbde06f1cd17c5e6b99231d82599ba0a575a8f520d3e8f5192cd938893cafef3045c49bc600bb4c4d017b87876119e68e12e7660c96cca8287f4f05454ba003f231b1166389a89a5a04499e4eff18372d3b20a920e89315a44c7644453fbc191a6096d3a59e0178b684b1efe83074e0e881a9e3764d3c187c9114502505aa3d76319ed8a6650f6efe9a0e892b490d12f161452e84c66dcf029eb0f00a2312b3b08323685c45be83b2a10ac0e3a5fcf7c6caa838e83af157e882800cad5c7d5109a7cfa5ef4f7cef6c4d42ee8210c5a105229ee39114225d4fd10ad60d8cb4e0a801af6e094666a558f202af3b977c8bf0a3524daae2947c5596c06fa8b047a6f82f49569bf6da16e70ca6cb77928b421dcd3465bfd7bbaabf1d6c6770d9bd55bbf578e50443c691d3f6ef9225c8bc4c30b04df431883b9e83d2fd5808f0c35353bc5c23257c5ed3fc7f3e8529cb822e4d7e076939e82bddc6baa949af37a25b76627fddd10d4a6a4020637304a65ec41ff0c828de7256a7a3c3ce9c87933d80cb6d3ebfcd62ea28523a9c708080fb08e80a0c6cb377180cace4c426a28df24096f6cf30bad02e2bf6fdec69e79080df89541c7692041f807431462f1694f3307d3ac3a79770c32d427478f1fb19967f9bb6d15fa8449d5d7a7ad33671d0fb04e19cb5e28cc53a08c37f819b33edcf2531d11bf66cdd6060081004be37014b75b1401f25976a578a0a95c523e2373bc6c1dd970865f34d09ea9f6cdaae92e468d2ac151d396a849ce51f4cd883a636c7a2ba8e30938b02b66b2f853b1b7b33b83c60cbf6ea15ef513710e602e22898973417596daa6d73c1cbc6f51b860bb62f4f61d426dcd8b63d38d2cf2b9c28cf7a37331f6befab9defbfb7c1432c6945440701276464cd35804146da333a85b23d4c2ab5fdb2e50ccc58d6b7aa17f786e295f011262ed50b393952f3f2c1151a512e933f8272f2a97a24a33a97818237aca68f66e718354277c072d7a202fbac69a76d80b9ec3112c536034a6b4443c904c2533340af48a24c8aff3b40bf037220abbdea6739e7e321a10ccc082ebad27fc78d1545a75bb82defcbce663e9237a8cf8102db8c12be4ba29109adc59e7e29eb040702625eea2d120529517783b1a6a96371a2a2850a25aeb323173c6a6a221f46c6ba73d89df5021e3ef8f753a8d8ac2450f08390305c7b6be68ad84f5f760911efc85ff9ff77b318cdbdd0ef941f87f38187b8430df0edb6780c39235c9a9000e544908855f5888e86d721f96c115007592393aeaa4dc1f62704b187dfacb42651805b88327df076103295e3b9b82c84a6eaee2da95c086d7b55c16afe270085a0b282a6e6810e6a8ec2cfc7dab82f805cd49ce222557ee91c8e7ad837cc03f7db0ef2dcfba5a7fbf12fccdcb4ba10367a639033c8954ee7dc2c123a79bde5ac7c2baa771d9f71930ec5eacc6f8f8d9e46ca992be89f5d6520df71188c48606b80227ac7142dc8accd474fea49dec03450867edd81defd0a366df8059f14fd42be07f4684395004828f5d5efbd00e83589cff6f7d0351b32debb1c0a2f23d1bc1aabb9133f0a28f387c4f1f1cccda9108d2451f76a4f03cf45777716e7e82badca0189c3d30db7ce1d2c2135a3aba173e337346773ef0281f8fff0eae537100e30b4e45f70a6bfbaccc93706e1523047fa9d300b518a28b338abfa31f0bebaeea68a22e943d89744fb97f7f35230d57bff3b85ead64b8129ac963aac42c6330dfefb095f021840ac047d2fa558e26ed7b9e409494c15f2a42b460802d7c18cb756526d0e7e1942249ad66c1491460d4934bd537de54f068330453394be9353445e24cd467f63926d0620e7309c736f1e5548b24c19cac3b5b69e08e05f6c94d62c668c9136726a56cc904c2d64a63b154351cf1ed5da44c0dd7759eb7eed1c2f66817d2f6560119db6ff3d2a1cf396143f1bd2a9c99f0657b873d3e52bbea7c768f45698b170750c6eae6ab39215fec32b6ac7a80358791428577e05dda27b705dd9459a53492c8a6d6755c9aafb98bc31e5fc2d1148c9a79f090491ae8fac81bcf31538d41aa727457f23c46236405644c48dbe1d010265dc3e17c183aee97348fa9af925611bf67a64efdfb071c32757ddd6e8460c51ff7466f7683e71601ac762726b2cf9063036296a9b2c90f273c17bbcbabbda7a7e2fa0c228115d02ae8b82cfc4b1c9abacfb91b7346748a0a0e5b5dfe1ca514271b5b5de20acaa305e595a918a21c1fcd300930c8f21581f511b096cf3fd9bf832e307edf890746c3516a86a1f6edeb3763d1270d908c1c082d1c585f715fb36f120c6b6b87339ef4d64900a858e4aab64bb6d52f258003af300ed27133c0bda1b28a7b939bfd611e27a75108220806cbc635883a174778f5c66991a4c07c789d0119b133c66be2d96ef35bb22a9cfdef886d6772c74e3c4103a1c737369568d00c3711a519687ec9b4003fe51083694049ac7ac2325bd1a2acad39d0590e8d2048d3c32ed6eed3d058f72ed541cbc43b25c9a6aa2a09d76ed3b81c2b4c2649fcca5774c508ccb6d4062342115357487796ca02004f0d995a65cf4c19b0e13fc9969cd31bbee7645e18f0790a43780e33f87a390917e635cc19f8d0070cdc7646d09ed18c426f4e73b89041c37b2e2a81b9d81cae8172c2ab1fbdad72f1412c7fdea8aaaf634218c378c1b43a99dad67411489390875663c4903034990f6790b8f46b8d3aad6a73b16d24bd8133c964d7497d2ecfc2cbdd09f594b5d796297c91d363aa435cae3ac45b0ad2af06aab3d9d757bec62950df3b33cc27d24ac9edd61bac35b51373d718933000781c552a820034a07f3a6608f30952eaa2e874167aa5db8e704507417fcd7a7ea8a3238c6aa973e58ee50408a8976fedba6386eacb4ea5f91ceda0c783b4daeaf01c39d9b9cb390f1382a0b894144036f36edf914452ff188c7605eb06057c8f4a838c8805a230e390365bf9bed374dd19346be4a3901353568bafa2787ca3134430a2ac750a41c1c2b5be1b0a3562432136651bf69391fa6e412a30d7fa040c29bf605c17749e775e0d8131bfe4c907fdcb8cbfeb4da98351177d638a9039a8c8a1972660e6d567bfee24b50ea180f44f82224e3509f755c158d7482ac6aca25a333c7bead857dbec179d90c91a7b3b343933a2dccec0c3eb8c1b653e99995c5d007f40a356d74e839fb23a9a3bc16b0b6a61a34beb6fe9a9db947222aa19d07baafe994496132bc5aa6eab51aa4d804f19be051acb4366f4ec402dd7783f6f0117ff3e65a698b94901440b75ad04cfabae993c815fea1477d5cdeaf865d2416ac5c211d05104cf06dc61a3084ad611b41db19dbe838e5957ebda9fcc0468e7c00efc73ecc3f3eb1113a02b872d77de7c270cd9ed06e11c1656fe2550985a1af61e21741313a0092d60c84edfbdcd6102e8225eee0ec6895c46675d0f50f6eb7a803c658d2b2c5a46b522e900835f09f94142e8f9722d9000d75297d52fa8827d6e1edd6146a4bdbaa971b8196b7804d0841e5c449ef3f650c16197f9f0f685d586d74524b5bd12c74be1045ce1461e8d1a801b6a8fcc16b4fb7095cadd50a48b6492e2d7b455e2536e51fce68d072aabd1f39f9d643608c7b60d66943cff63c426077660cdaeca8df093164404aa2bad7f86705b26cb71288584d2d128daf4c66a6129094e887c2110cc3e2dbeea58545c989c00b43f42d506f0eb582069478c03586d8fafb059f8107233c204f73151bb1ad9e36f7c30078a38facaf3b1b873bc9cd585a953357f72c8c2bbb0a8b5bc41f6715f16c311ff963a4966fea01781527ab54c6e12ca047580b89ba3a9b820bdd6858e91dbbe8067aafdaf082d3725a8b03fed3a9828a3482fed3c02db9eb26bba04385f2df9a2a690346cc062526068bed9d58586cbffc39ed8fddb9f9b37e261bd6f7970d7b395a4a83bea8f13f8ed8fc042dc3b9845ba98dda006077684ed2dfa10d7715546ddf9b9fdef64feedc0934a9b58945c51b98b0d041020b89131c484f7a772824336f141ae4e9ebcd199601653960dd7649edc4bbc30a21703acc05de3969e44ce1fee5a643b3c41e695262047a5a07e95651fc7c954760abaf4cb83f97067261390e965e0cff3084375991c6f1fe700fed77712c0021cbe5f580e818320bba2433bfd99b4ad150a2a3f20fac3b23bb0c0960b5f19723abdb3dbc1b72d08c16902dd90ee0da90f3ba30d0920398f0446fc924056306ec5af3ee8d488ff32a98f024776fc9ea8afb8c0cd76b2bbb5156bd2fed8913df6c9475d44105f04071730b483253fc32eee8a0a75dba71338280f14ae77a70d03a294ddc09cccff64f95d2b15222762281aa1e3c785c444f338d6ad26ce84fb5a9dae0c358d1a72b7ace2d327ebabaa2e508d7b4cbf3a15c1bee1c8c73877ccc834781f0d405e11f15380d37bf03dcdbe1e7a93b68db84e2825710d570a3d9e22e8cac194885604bcd9b776e54dadc032661c40ce6ebd9f1a0d7fe793af6e3304dcfda5fd6955b24c2086db867770dcf5699fc99114bf2d61cc391aa1b2566cb4965202d12d069009c290197e0748608bc66a4aa4f3dda60bc92588284d3452fec3228358e1ca586412875994ccc792904e76d958d0391961d4b8eba6b97232fe05aff24993de57849f684f9e28713563597b13c82ab24d31c6e237e638f8499da73ac85092baebbe28167473305e60160dd262a8f11b39ec0fb947f9563f2a44e868419e4fe8cdc4e9b6072d49afd5c2844cc2cd367f0af30a4a31f2bc147b6ac711455319ad9ecb2eb183e6dd18747c3d9cea6f6b3d930571845fdb759d712501ab24d1cd3cab428d4630f67caa58f9416009cb6212b53420cb0309f1fdc3a1899b6753d8793625e4aec1a329bf90d31e3d7a8d9ee8592b65888e9659f7c4c4b14dc5108a7cf71e5781c3675889d11412defcfdf26adc903a119c546f215b6959e2d9b36be059192ca62e36340c1997a451915cdb01c96c32d9ff6e65090c89c4df37894bfcb95b10c2475061a87a0d890a8be64eb19c5a6822ef0d202671f4b4330b6f7d2be93df4509198795cb75d3975214abb0ca2884f76861720b4a7da40afc2862bfe76f7978224d07e3c98dd29d3ff27fc52d1155e72d6f526f9c6cf40631b7248b9676f7b9e0ee0058aaef217f52c2112a0e34672d27bd826b834bb1c5ec3cd1e54e52cb1709bb1dd419f77e185e5796f99c89041ad96ad045545edd01cae29d7b9d1e5aec1e9e109b0dd2b4c1fc9ae2b5d8fc102a4c6aa1d902bbcdcd4d23578055303c28d24da04d1e362739f123dc2fb39e0cf4345561a88412d3c9e6490a38aedb6ab03551a42cf48270eec075f6d19210e3abe52f11453d343de565730296c70e66a59a162be16a6945e6c0aa2f702f94fbea0ce575ef66c523cba5121663471eb405232faf0417161c47946117246065431445c2f939260cda6960184eebb61ca021bfb0ef545912a0ce8a5730876fa18db87ace35aacca75905cbfb934863d928a5417508ca9e28c79316612f56863f4540048c3d7c5dfb493908561819b546a14b06d1dba62bc8da77a85fe9738d91f96e1b84e8c08a5bddbff8fb348a980e97a862752621277a3dc33d6140ecd7154d2a261a2a731cecaafea41fe6f1213b768e63d5d6315a795c01a04b249bd7529f31599c1a0c6b66443cde193823829ca8df7ec08c4c5b266613eb6a9c6182460dccff90f750d03fa4ac64a4c15fb438d7c01b194656ec11c39ce88a8aa19ad6d970973e2224ef06be1b6c0d9f4008045c6e4dc3f8bcce3e295c164445f4dba44092f85b8877ca347ca7d7406f88ba550c275aa27bb938c9ec24304a0a9882960777d4e179d39b0e834a71b023d9c65104120e96dbca02b1c6a08998ce8a77a9093f2ab89d26e059815da62c68e4315a28ae05141addbf58122d0abf21133a92989e2f9463a2aca12cd664de8a2f52ace184a11e63c41e73938ccfff23dca9eba7996ca8f3d182806ee40613a55527470730dec7799265ae116a6b09d6702c3e7c959b1bcb73f29c4b76c2d29dcbc193c44c4c79532e98407aae8d59a1729ec958895c0d1782ad54d94dcc8cbf2b09e7cecdd4d62cf8a8898a4a840ae401acc1a4d3b6734c2af188fb41ba50921a38c05dcc650bc20e449869616caf05ecdf83f441cc3b0b450c4cb4f51c54cab9d5c5482862bb9433e2130b9b88c5dad5ba9a100bcab91ab20694864f4668de8f85107fc115d58e8651711483bafbd1c9b7ada78bc0984a74a2f115fb29fca37905615b6d7cf8cd78d657d61781dde1b4ebe39724d9ae44ff838c103230cf87420e3109d5904b40757718c197f8ab49b9f0d80edd7be5130708c4814d06607c9fde8eb70177d396061557441c110609993618b3bc398f6d4b61d862478ba34346bfe208de8dcaee6ba4b7c09c099898f870bc73a7f9446d95534209155406a48ed509c92a21f9aa0b2680830670667b353ed502ec88825957c89a1ea949f525f8c037659d431aaa162f199a687d30d844ecb58c8308d07a89740260167bc740b2ae026d036bd5806a71a054d0045255e5b47a5ce47373d4fc246629511d334779e338ea981b73d9be704fdb1afcdf61956c616ef20c062609db20f33a2e3b76ad7cd3e79101ec5b81c933f047a9c2cba50dfe8aa54537adbdd3d5e684c21dc76c3ab1a7429f4c3fb74790991465bbf5cd673ffc4e26281587cfa7b21938124bf431b2526e61c368ab5b4c0b41670a9bf65d61944cbdc3fbf1aa1a3837ac67671474ab4a7da9ce02dac2b5742a100100771dc8072c3f29c5ff23b9b7000b0472cae8cc1c4688b1b141d944a043e116cf672837fc88abff596d2c38add3e910396ccdb3773721b299911a890f111e07285abed569ae7469b1b23f19ba0d9d12aea756e6c2dd59c085e8c0ffa73eaf3147d48b210201f5031e938041c6d9bf0a788435940171b0cfe2b854d30d08e5ee1602fca4bb69db636e6b6c26dd587b04b78f9ad147d0dc3a4780abbb367516d8bf338fb868579e32555161ffca39566f75e9cac1d80a79c211053f7a07a431f1a5aec4906ce627dc1ef965c3dda1d863c72262c233e88ef9493a0641e1a51038828a1c15f259246755b4e13a154c21dd5e26521a911b529c6acc6abca7bc092920768651c9ce8f15853d57a8c06fd9c06a2ff4908a456e9b5f4b6a772fcc929535a7e299059ab78118ceb018f52183ebe511d5d11456de4451e02ae462833c490d55a727adcc009a0c1f226ae142000b7a6ca8dc7f4bb989733e64f8219ff2ab618e6a967301e6c92d413c20acc1f7bb980924c7c67180c385f61d6ba4c962204e1f36bc6ffac3f84f0eac455d6abf073882a662e3a0f1e82c4199e35f36ce2771d8426b92420695727f82e84a4d0c69d5b7a1477f9a45880bd63eb0b54e88a74d0aa1d4dbb5ee59869c2227a93c5cf9114489369417782a08ea8c23ab0723182fb4a4a9ddc80928d8b643ea2f135c87a3dce29e272d7d1b0172bcacf1865504b13be3d89832d4dd90e21d132f99a54d342373dfc26ad662e423d9dea01f631f4d0b3083cbc3f14efb84fe01abd2e92fefc80afda8479fccb8a01ec502ed3201c3f5c9882776436f50b4ae76d0fbace5379c40724680281a2dd7de84ccef6cee3af42935f3824bb8fbd60a43f662df23e5493522ca3f5f3d79dd64c73f24d8f459cdbaffc29c99e71d1c47d82efe80a3f22bb56a1fb4204c75e524d5a566f2b48ef876becdc0a678703106187e90e25fe4340271aea07586698ca44c856e9eda02048a450b7fdc8a04aa501679a3b0045986bf70e23d52d984bec5f320a30ad1edf98cc9bb8a4527d7d1e4934c8013165734254753be029ec8aed5e307dbc28bfe613df4e695801fa7ec6c54457fc57130a01134404aca131d9202ab7803e85c4ea9e069ca39ccd51d8ed1b9d647aeaec6ac87747dd5eb5cab7d78f528e67aff6208be87b05cd574c0e894949bd25f9994ffb96be8bb10501c1c02011dfdd4b07a87e7687b700412a6eef4390f49a0ac0d8eb3cd85500266ac486df40fe066024473514357ecb7da594475eb10375dda74b79f46a5579886e0586e7a55322f25c16fe794f73ed29b88d628117af732cf095affd190a2156c233275787884aa7a84ee3a2f8e1fb9657eba8db5f738e49116c00c22af6bbfa1ed0448502b49ba2b2c07071ef5911adb6830ff6ef88bfb02e9b4ffce3f7b0165b0705380865afc789b4cd2a436d55ad20a4b564a757f3ff4335adc405fbebff62fae1e54a7bac7198a9584905824be88932b7d703d75e6cd963a1a851852414608b5a67d35b9a4984a28eaa2df4051e4ca2fde8a27f30966de79d51c7b88194e8f4781bce9ba7deb81d5cf40d2d81562be719e0f6e47173af18d2d1cddeb54500be82ac1d21681bbc70e4a3c28b083e3eff8574e9b31d96e53006319a03545cba814b8270d0c262ca95e27f94b3c98533f12bdeccf8000cb402e8fe13a1462e90b1199c351790275a01fc76637aa122503a2fd56f19f80e19fdffeb4e8799eb6da4c68a8c7dad7537baa10b41f138a1a2414be714352bfaf1c05b59764eb6821be532b74cfed12f4041accc1018461061d515564ca6c1ba3cd252438c1f2bf04c7f8e0e22e00314b0903ca845750b974f1ac4eb686b8c8fc226bbe60b2472021718c725c1f6dc2395dd8a63ed22f3bc1a57f20b383b8892ae1c8e952f9fd8a1aa4b538f46f6234b06afe4cb8e9eb015b4ac766467f0b83534e061fc1841946909e521c44b1cdc89156693e567ec3cb8b8b4428e3687d29fb40f276bf9567fac3e2ced447a3156beb294762879e281dc86fb5f3d4dd722ef74cde43c528494525702277f9fb248a66124aa223b362c4609cff6861791e3cff3364ab977ff8da383425c9b5911913f0aaae4c292163638ceaa2354634532ad2cfa64450305d4cae199648979a4a0aea1762bd5c28927a0bb8bf3907cca7be869610831c48e87423d75f63b1abc0722cabe88ae9bcea03895c7f3605796741828cbe7859b2370cf30bb0990b27187a0c3b8af5dcd77b2a8976eb316226f73b14b8f2310ba1c557b619cf9be803fb8dd04180cc14a3fd15f051163f31522653e29632d333691f86ab1283f00f883934bf2b3455e9f29066d88724a1f2957671d5ab79b04b07f2cbc3fec103f5c2710ab847f1b55cb18fa03529140350608077ea955e9b16bb3ac2aa651f1adab903a0435c12679361275bf985665a2ca539d9f58688d859b4f7fdb2b891c495eb4de4091b3e4bc1b895398345aef56267b56cf094d2a5e12cfdc74a6ecbc2e788e62816464819bc5e43d046a971e58f568e7632017ec1421714928ff69ebbaab7f846c90b073f263e55d2ea8ca4cf81319e579dc886235975689fe51ccb7a7de60213fe83dc4471f3752cf7217baf2ffea73bb08c12745fe948cd353ea1fe21985473b226fcce55c83acf3fa8e30fde0ecb040fb3c6bbf4aa77cdc48160ca0cb44c7afc07f338e14dbf37676a67fcaf1ab57b2890ca450445ef6d9884fd195e70b9efe749d297557bc0c5bb5897fa2762363b3f27204758434c13d28c397a42b0bb21f9e6f455a6a48a6fa99f9a6beb0d9d32cb0fb2c6d607908c8b60e9cde8d040e69af4c740ebe256f6be6fae70952db482c5def0927f49dcf19b3bb4f95b8d153e48347d69e6d3f8c1a63d18bd98a22a412c21dd4d7f769fa68376b722b3d14282517a9af18faa8321e5299a60989fc3eda506c7cc36e100ab9ca49afd1035d189d8d069101d29768dd070e64871c45a7872f9d179582c49c71255d624dc10b9cfd55dc3194389ad92ec2d359642f9ff083d056bee31103b15e54215c844cf5bb06f5e3ba566c0308d273811b66584bc24eb0f3897cc4cf8f20ebcf95c8d89e0c6c01daec5d8590dd44e6d2eca6fbc3f94783f2194200651d933db5a8631c3a1f2473fb528243efb3194e07b58ff80b4dd699139c2782fc60fd0f85f80fd7c6de58fb67af55411361baf3e2759667c53102237a8d822ef9f6b5456c284fd5c04b9b55b933f5d15acda6c75dc217dd45a36fc08ec5b316ed64092454738daf1581bb66c2194d19e01e39b64baa96936415ca81c7412dd35836fe838a00f05a8cae5929cc84c495a172c41b0fea23be88293fb8bfc3eca690bb6de65221497329d807411d96590256cb00358812ed3b9ccb8685ff7e6ec34df55a3135237fceaf7ce35295c14f7e957502363219819b55655f2469b119e381e60286785b6d5768fec604ab97a12fcfa146f1ada86c27a03c72f58e83c641bda2d9b6a18620ef035a901b7bce01b948606590c71a479b7e048a21663d3554687ebf70cdad19c66d17ed4df467378d6a3c3ca10e959e4636a7b42370a1a4f6a8592b035aeea67ba762e17b1d674ce23060d8d77d4a5c3de2e367c7c5b4a3716773e2007cc1f281cbb8bde348ae02a63f6c79b8be4dedf80b888a48d34e83bca6a3cc3faaeb3405773449b4f0c94381feb6f0adfc851f1c1dc6c8190ba50d6c43c46aecff51c4d96546ae60d150cd4415243bc9cd965ed87140ea58e387872c22c22bebd9c04daf7452dc11d94233966d398a31a372dabfc89a4a54bb6c78cef03bb48facd45da9114edcba870fe3120fd8681419055edd5d762174602f694f4322b756083616a0997f9a3203385b538e3fb1758e8f09546a0eaac87f38b7fe57055fcc283b718ca3a463543c026db136930e2e3a63c1f73b40974f5599a7d65a7188d2730eef00ef067a3b94974598b0ba9dc1c2646f1c887fed1874dc26116d9da9ea7deed7d9487dfd2d5edf9faf900efbf100d4556f3c25bcf846252978dfbba5e3ca189d324dc33066ba7c6ff2fe23f97176b1297d77e1b0d868e0d07c1d66f97df1c6b6b6090e363268a6891304ede8a088289c7a945346d7b11932c5c4eb01218efe703e5cc5e17985cccc0a87ded97239d99a0ca1b29d3138ba836444d664fe3bd84ae03fd262cddb9b63cadc5617de0be140e5af0e7f9aefba2cd993d3a2dcaf33b2f0576a1c87553acb6ab722d0b1f6b06e5057126becbe84a6f9186216ee82d6edda0cc16d181915abe3bbb548822c764febae1011fc386d01f97470de629b589bdd0cd832d700c6610c28b6ecfc271ee2b9bf1309e9cf5e9d81669829c955caf2a8d8e001f5174da0680f0c9bdcd744e9eafe69b35a3ea02121fe2df50869cc78be216714c57700c3fe5c54a2d7791881b4c8aee997a667147fbe6a52bbb196139fa450f383eb45ffee96cc7bcff8a962e70879b9dc609e1ca2645314814683e52ff96672ab06fc75d96c77f28378f895338346121a591509f6221a4914f0187d3e612e74cda773e04ac5688908a9b4b08e33e8b5ade795906dcd7c3bc42a9d0ac91af8e3fae15395cf3f03957aade5dff7a7cc3a416263e0cad04efc610573c7368783c3b079836502e6bae9c3be4eccdca84e99a959f22611424d48b4159ae0517e6c8384c54afed9ca3354409b9082cd166f3b5ab0d5f1db1556eba79298dbd0b49c2ba0b9321a0c833574324e9726dbdd7ada463e7c5f650e327ecfc2412d3ea09264a2cc1e6710992783c75ae0bcad5a6134ad2f52adadf59db83b29b2d2372fe536cedf971c46953d7d008be2990644290153e8de081fbff6f1b6624611cb83dc5b505e8e8c222b2d9da9c08c3eeb57b229e36fdb62c0c5226763b41605f640bdaacdcf6ea40261ccda5268b64730b444d5bbfff74844f58fb7a1923361714633bb26f83ee01e52ff996092a8ea16bd4778de0887d35d01e68b7cae05448123b854093c0effa1f00a29450b4dd5141d3cf2c9abaf9ecc1d465f85fe07e8e2b1c77b9d7bfac4272e75dfa11f91f22c52b81929b01d9140991f068a4ee3231c6f148cfbac89096e7dbbac5a1e580b3072b50678087183970917140bb2a885a610422c686fba2f6bc9ca847b5f1a28cbb5065fbd5714231ac6ce469bb3428d630cab88f8afd1e66f1df20500b1e09c70b90cc5b9f1bd16721b4c764beb43ee763c801382349193cdf5801ee454811831200fc913c816c5ab61925a22da894146552846f7156a1a23069884bd0239073acf8da93061501cb9b0f4a41bae656ab35544365ba589a199c7fa283e89537d60bfc77b1dae9c995a64570f7f4c0729948d2375c778c6065ce5f27d57c9c681aea829f9a59c9a531add86fb5e0d1ee114fbff6048757b73cb1300f9e34b4bd8f3ee13ee408e73426abbf6e62ab8c1b47add4c876d0103c094285defd2ca1313ccf55cce3e520dc82d9a4996587fca5dd674557cd6102730449aeb1118f1e8a29621d8d120efac2b21484e78c49cbf15abe0d155ae15c4365463ba11df987be78f026fad727b568651d767a210650e20786e97b09cda3a75ab5db1c1ba506703c9813f9e33416a4d3ade1aa8e5472575a74a95571c8dc0b350bc4d3522d44479c315e825c9bf7b084ab51ce8332f1c4b18c5939ef411f38f54aabef22142728ca1cfdd6aeba07214226dbf77098c75e3c93310fa7e23d46820274558574a6861da27e4425113c9962c45550fb3ee2e31149aa546da59ea03effd50327d14fd7dd50767ddbb540fe7f81492c268f765d599a5add7b63c55e5bab42ab7d836b3a48ab13c5d3ceb9751da1c67c29f3b2154018141b308a254fab9251db79c5159a786b167762f3d4feae216256dd7efdfffc33edc1c72949dc34663a80f394f7bc7c5e79abc1646276e4535317509768db7adac4872a0a88c79ba845c781ed0af9ebd34a522558d8c1f567764f6e1ee89da9ab9ca40a4ea6426c9582589410559a9e2ee96cb9df65e4699d0ce9d72be1a3f2d792d0b95a981204a67219a96cc1b6d49bfba3f39c308aed3bfee2e41c3402c0560fabab80286ab1c0a42b7eadccd2b6f5e7f0f2a6dd173c7257e59bc1aeac5a69ba040ce2cc6f417d51c4b904cb6005ffebb9c68e286dfb65684172cff3e33239f6ba3a82ded32afe271ca59c9476c494fd183a4eb851ba14f31a9fca7a413c04839d37326f6f06fe06a77a199adc2c813099509a4dc45fbfbb3744293ce6e8bf8745c40d79150856cac019d329507e9808e10ee52a47ab436fac7ebead147c3f9726e1fa4b00ba6612d6273d048d2138768c17642c4564c491640070c2d0e15770bdeadab700bc0a5ac5266c3269b3abe36a2c964d7e4b63929009e48acdc466501e036a63d0a91f6cb29938510732c18b84fb2c9930ed127f77fa0673b5c7d1005c265b7446fe53dd60e33c4b17b2851ea4fc3d8550445b53551773e483200bc2282fdd135a163721be8a5ec7bc7e190ac4db2973762b82128d9f127a8f078da8305b5ca5f83e3c15858cb3385bda3982d42523e0c443339162eccba3417894fc1ba08af4842e6cee0d1b9fb6b4c51d746c83fe4d9aea07909163c15c6fc390741a81f2fdd63296248bd7cd4e9823f771956b20ba410a08a510c91c6650e7ce8e68ad69c2371421cc96c4a036713980b2de8247035f5c9f663d94bb1d6ac66c0d6bca00aaa8758e8b92393a151fff95a9e8487c4bb667c836f8828742b47aa1ed744856f2e971d3246f28cb295a4aa9deb215fb44c8d4380f12e641b9ba40ceae5db4aa03340bcf5a4ffcfa06996fa6944a117768951a281ef41d45b4c9e9398d54ac9bed41722f3eef3973bb0ed5f02eec0b25d8ad383532f6f688d92a2049b1d10350090590a8b75124dc2b40568de4e4435721ddac164439cad00262bb104833c0563c844410f2bf21e7f0b5856644063b23cce6c425cf29c2d4d0ceec73e0ea1a11bfa230e91a661a8b4dcd41c0e2cce59bd4c3d231e51ce76160c00f038b72ae49d7986df5a027c726a17f52e776edd7ff228e0e56f6e95aa38404828a18ef9a02dc1d510e2932cc9cadee9cc21d201f9df3a0c479edade390a4b6abe5c184c8193a994860390dc321bf130f074cac134a7c310017b524fdc3ec555f3f1b3ffb649c13da674d032ccbfdb49fa85af65bb8fa3dc1622314f2860e9c2c2cda8c7831431186960b1ac23cde2a4a3d3a0900b99d25699c2c4ad2197f9988942f3715c95c440461af5dd687372b52d114e6bed2c21588f99c8ac3efe34e54950be52b4e293384463286aa457c3b1f3634685bf226aa93a121b0a61b213bc481bd78f83cc2b33d03d3a87347909f739521f7d8ccb0b41ad457ba25bd5ca0ccd9ba4894e5a3c3a2d7777859499e826a0e519920d1e9d693a469cf4fb736aa0e3c9976ddd531550cc4a30243fedf1b0a1d88ee7c31c99090d33112280242441e2d455750e582533136781177c4d4d8e7720327347274ca9a0d819238834e5507400a1788cdc56fcb740d394a036e8806030a2de2a41ffd57fb7223223e417151a523880341fe47f4218393ef83a6668334b9e042d8e999217ca8f6797f8ce3113bab972792c66c175a000762ccb76ed04defd76216d31c9d2dbabf05e7a04911dc6de36c8501c1712cd745e25190ac4de3038ac74acab427b4ff04703a5b1ffa2d4e89c61c4adfb2cfc5ba1608cc25541e1a202670be78350527eb4a9e5019a6961d1abde79063dc3421983a90d854a39fdacaaf34383c40b679bfdc97175308963ea3f4cb82d5905b564c24c989f9c388e46846a010426b04b4ca50c4d2d28902465753039c17051f43e31ae46b2bcdc3e992ed487c52692b350369f9e2be66df246bf73e1d9fd92c30d1d912e181631807b2612b0555d21b4b2e13600f72c61cf86f2d584f34f0035d1a8085a57c1f376d8d00e4b74b6dff0c01b1a055e46614f2aad2aa5b3810678197decc738e212b73d4bb4b8df46397344e76bd03ab38cc40b952d6c8bd9619fbfa565d682221c600e1660b115b15043b751e39f8001d8b75247d8eb7858607bbf7a13ecfe546e48d6d6d89f8d0c31df7ecc38736ebac4af23bad256ce5b9c60be107720abe7fa7be37213560cb4f8048e8204310f581048c98a732010236224402006466452e20240808ea87b26147311a28c1c95cc418888879e2bbe660c0bdb2df45289c60e14f6e89819d114867ce7d5591f214e235000c0a33ce318da1cfbf8fd9f9d9bd976131122a594291e0fc90ea50f23ce82b1e0977ed009ad1f5349851f04ffd72ae2840c5fc8cf5721b82ae2046ce5203f559eb26282f5c5029000c5d082fa228b033c71f9828c209ea47c81822536c0e58b1f2421069313124270a04ac880fb7425cb78e814812038a025cb78184605aaacaa388d2490eed4c50e60308240ba53962924ee79a00027b238404805a8387921022730c200c257f9b6f2d53a48bcba39e79c554130d640609db3c618e78c3fb770beab9e7c73eb4616b1ea7a193bd13ac8dbd2f8f515207fc862b1b2ce7dba72ad8c60c4b1c8202c8cad5809027aac15602b55a85c7c44be529a60995c650b151290d18405cef9083048adf5e36e178d5d38d762e55aa912e631b3b26e5d2b17a3c2cb749f84ba0b058759b7837cab9059062c735f59e60c25ccc04034bdae95bf0106ba1815beb04bc669502ed66521e4a26f30da8065ee17c132f7082a404cb94d52d4c04c378801ee5ac1c5703c90dae543622e20f8f08502489676f2a2075ecce06227efbdf7decfbb34f96f4be74b733fc4376badb3dfac0320b690f80877f9aac7ef962d774b149e93628e1b5b8cb81c8fde203fe6373c4fb7740a7e18f17d9a42c4576b0cc6cd39e71ec4f08af13e0e41778d6f07c49c5f87bbf7206aadfd86fade0ddc6b05be6934b956a96e9018631cd21fe0793bf0b58148bbb4af75514ab43b007d6fce37df7cf325c167f0bbe3a71ee4bfa187f97b2c256c7931c032d94303bf72fe9c6f17327b6864fc697cbb60991a58c68465173c837400f09071ecc98822dd490b2bb06811858a74272d9818e2f3becfdbb1830b4031450a0472f004edcb8209551445dc7bef377e5b7c5f08601c67d470d26209564c0b0290364877ca620734f0eee7eefab2e78519c7d2d763919ecbf3aefecfd3da09787516d8b58431d78b56465ce8827f26af135a755744fc41d7132ad58b9f7ff7c503cbdc4779e1f87571c8ac722ae2e333911cc232cf7b8defed4118923e3e73c11ff77a5d272ecc20bd1444ede5efcb4e8c3e458070a3be610bf722c37f01c355f8d2fa96aaa5573d62902cb6bc4761d4fb0a44c5401ed7c713aa0f82c3100c2dd8851b49d75245c42f1a109d686554ce222aa37246e950873ad45aa3b29882e421dd298b2c64164a3865714410305a6e01a70530d1c01a8cf8411c8ce2fb8a06f1411b8ca996aae5b4a61137a2682e645418b67028995de80daff544ea532e8cbac0f8f98989ec0efed772f0c1bf2008be6bf70f5127d1bb177bf73dd71d43d4eeaf8cafce307eaf28c4781dcb30c63a60dd9c73d6a9175128d4a35028940be77d08b634e8cadef2b2937e8598afe7b9bb5cae37f0e1a843bf58f2dfdf810346e2724460055a90f9c72c8132c8fc190269a8c0558f0e6b2280450948fcdfd88021a8404097347c10e5ca0422c001d0db310112bfce1010239573ce39d3408000247eec2d162854d0e0c90c9218024b192b2870b00c87a086c47f8f86c8810ad2f801096a00020960417aa295110b08ec48b9601c516018e043c15328022ade09c02b6a40459fc1f411c0875c02333c2282b8c14a0195acc38b05132478cfb8c1196a8c4e5844f1830934600232306b024e1360524d89820a2592187390ee4485951416548021044b17a72a42e084c5cacdee5d461ccbcb1a15826196c99ec62ff8c12e23cb049916c1049c0883bc2a9628de1835ce9fe3cb1fbe985b0f62597685218b15ba583940570efcba2f6f8c11c7baaed7ef627d1e768947b050688c2bd29dae58c0123b3cd76bcba822dde90a22ae08e28a1ecc882100025a0cc089165810b08228c8e892800ad0be088c4180718c0320c0f33ccff39e7cdff73df107f8c09b717a801a31a707a4418640bad3034630c59d819655f1c3095670822c8ce8020258d020e79c73ce78d5a36f904f62272ab4203102485cc4003e60c00b4470041a50b0701233cbc90a261293188711832db2902590eeb4c593130380207390eee40414a408f3c500a95831fa5ffc26ab0f3fc869acef57aeef9dd0c21f3fc869a3ab8967dc08f3b8984773dacb7f4059e65b839ce6f3bdcaa51262a4c5e0952b6648f5e1ab5c4cab577de8a222f55ebfd368085f1c1fff18bee86a729d7c311ed0ca1503047ecc90eac1573df8979661709aea45bd24935705f2a09665beef754c8a7c9634d66e0fec7a62fcef6daed314e5455bbd14166dfcef320191c28201f9edd0568ff319909faa75a7dcd595825f1feac3d58f0fd4d4a4fa976f121fe65b31fac777425bb556abd7bf1a5d4d605c37cb377971892d55ebcaea6221bf57bdf85adf2959e6fb269f942cf3a5ae6bd42ecf9e65ae948c22425c97dc354826fc173b8d2f9fad48ef81b20eea3dcf85226354fdeac10f63b22b26bb9a50913f17ced120bd4f7d760d89b52c83c5568cffcb93139a1931ee7a7f51fc17d115cb32de37f15e59c673c1c9d5c6a3562d175bde8a19125da917532e6fe176b2b0c21f43f0325121fa0e263264b9c776522d54ebae42264627636c90978cf13c313f2e6c4abdaa09f5a22b489649b56231de4e8ce77ad47b9e6b08f5222ae5f2cc348e3ee3bd0d9ff1b2cc536e815669d5f73191395e9592a51e173e4a0c5baaf055a1eadeab523d4aa552a93ed55af5842a2417f5a2aa857a10f541308ba552b9448d5af5803fe15ff08b0102c2afef9d446160bcb96af8f5813e8ccec50871f58f79c11f7c4c6652bc0e9ac043cff35e861c86e3c862bde781170bfcf2be0a7e794e6096f75e3886acf159af67913b2c126cc548cff33cef73dd2bf8e55d21bd0f240008272db220590d6862799f87af68a20b29218802e94e569c41a69480b28200c817d29dae08c18374a70754418ea43b55f10354971b5ca0d2c81488c0ed22558553153cf072407a52e82a7040b240a72a66c085152da43b5951c345ba931533c858d6f92c9377b8a2330279a91e8c9ef76120df5510f621f107c95cba9037708edbe366c1c27df0101dbe4c4c4c4c5568f85558865db856930b18dd07286b5a98fd09b743ee903946e6d78b95c725351263af0a9dfdfbbecfe579ef9eb2f1fd6703016c6901a95d35f3a601fcb2a1b50a47b6017ee0a73ddbf8e1022f40810662a00ac2f38a70f118708b384515e9e91c7a1e0e75c584a4d7003391224c96e13e242f1379bb5c2e242e7321ef67349c069a31fae3321af825f499efbfc758e60b71f8d83b038f21ba0e8d5feea3d3166a38314009929523df8c02afe9c0ebe85cadfd73ccf7de2425a4858f7a307c542bca0e0df43e1710f84e0e8db4900c5b200de3fd4b66190feb092c804ad6543491998a2964163598b5feac5d483ae7ac31c6f92ec92417ffdadd437777777777777777771fb35c2446dc9358ff156fa8310eb38cbe2c56185e8c4372091d1d8218e38c5f870fa2bbcef9c9301c47164b8763ec63e8f718c7f8a2365080269ea600638b07933fcdff8487f85538bb9eb8efee62d2ef4aee1ab4eb62d2ae182534edda8107df4263f22db4abe402dd2de4ad816ae5b3fb38422823ee499d7a1145a652a9d407c1af170abf74ead2b48a257afaef6399db72fcf2563da2288aa21332d5c28537f55e0bfc30e524ebf7f007c12b9f89e9268ce052040fc80b60f16200e0bbe7afba7f69ab8f7942f5978651290fc11b1afc8f02236e6485ad1c2c11d5ba64aa85d31ff3f8053ef8a80d80e12bcb802fb66259060c411ff8057e08eee0179865c4ed906768323e8d5f32905e6a8d51bf5f7dbd80f9d40ebcc78d30301fe56954842fa25ef4106edc6885d002a165c315be485f3deede5550986554efa977bd6ae12ea97239fa22c317897a11078a8b11373a7edd10df5b4e32c9412f29f7dc1a3d308e8f518fbf1f5b3b300fb670e88bccff7d305e2b1cf300c6975761af06622a07232a0763caf4195ead56d8f4999e046c71420a0da4a438024cc30c328a905124e79c4d9fd9f95cabc81aecc02f8cb3f6fe86f8e5c158d61187983e03df87b5c33d2503d6c1c1370638c74220fe05e951c0f38b5f42d70f2034fd79850493a0cb87cf783f84b4705cc6fbbceaf1815364077e7f79efeed940e6af65970ef117e5babbb3e06aad5d9f277083358e588655e3a33ea65dfa318e8f572cb6e466522fe07edff715f17ddff781587cf8bc886280b0e9fb7cf03ccff3a27401863104136830b1a505d805146a8cf1f7fef4b5807cc6dd9ffcc9fdc99f9e60b8523cf70b5eb958e42a37a87286143798e208d41458906c482e81f11d3bfe5579f2198cc7a8f254e5a9ca5395a7a72c053fc99065700d9b37fcc29a090b08a662305e2032e5ba7727cbdc17531abd995816cabcbfa14ac267eebfb47459e6b288f8fcfb967c0737c4ef8621085e3204afe7aaad2e50eaa66829d7bdf219c104192488028bca098a2d48762497e820ef3f218a5be01be69cafbb5f1e2ec635c859875ff92681d35a6b13bf72ceb5140c7c074c7ce6bb3aa481e8dea581ad1408290a9722751289ffbe17625ad6f16819e3ec24637c85105584a8e2988a79fd8c1ac618638c7782f800c9a06b997c35cf5f1e8b8871004f583c963ca55b9f0e64c621124c86ab1e5d96c1af43630c5dd3bcefde4fbf3cf1f2e26ac2034d748d2c2c4a5cc67b13909e02be17c1243ee33da67dc0491459b278199f350ac4a82a2f7a7677ec9eb367779ca7101dbbebb11eb9b85815e63188d13196e5971d62c8baa4a855de7741ef03f19875766019fcbf45b72e0d757188731afee3084de5fb3eef7e413491df007ef0063043e2be497452c01024cec140c5728a74a726cef8300003e5fbbe5517284d7c4f3481610588c5876f08ef2b036582209abeeffb8688f24e4b98b1041924ee632f1f58020cac3510a413144e90dad56272c722714c989898dec1fc77056af0b50b975fff975d4819f470fa3f97e7b990f26712493bc63ea444c93428208d0a96490a141a2e0c33154a4c41ba1302b2648074a703e000abbec7ad487ffc7795bf96fbcb054d7eff6517ee71a88818b10be907e7ff1ee042c2afc91c867ebbe08ff47fa9544e68fe2f3154e259c67bdc358389ccfa1f7fcc8f0b8773ce9ec657a28898f41d22b8c678df0383501fee80fa700710f5e1a3f0f7a8ff1e85b1eb738559e68ef70771553191de63f2b3c1ad6225b358ff7fb36b25036ac4afd0ff7317d085e321fee7c2edf05cb81c246e47035d5c39703b5c3c48f129e8d256252f96665242256668b572e52e59062b51fd5d29015a7d10ac554d5e5ee584a61faf54ffe2c2aba197175d4dc4c7692a2fa6de57305cdacae5af4a7d4a4c7dca25a65adee563f2aa785648acb5b470f95161ee1286e3c8623dee5611b396aca39f58e3b3f42b6bc95aba746989d7fde697989fefef7f2e27246a0338fb87619844ad3f161a3e6689ed8c1f739dd8e83a6396c1adee9b32023d3d3dc562fa030d70e2070140a101171094d10505b6784013d3367f7a6cacb8ac60cb092e50012db2c0020a2282d826110e36d410c34f4f8f998c8d95181cb8c0120820a2699b3804e087484f8fd9cb4afb0ab688c1010c84a1451658580145114234dd10809f1f3d663a38353220d8d0bec60ab69800031708a3025a6461051445102144104d2920bac1861668606af4a0c80b302f25c83105881f648821a680207e586242056a8dfc03ec03af079807a1143a0a0c057ee2dae09a1cbb307126b3907f041d38c78d0171e4122e4b937047408500020879d430aa9771854355829823650305861f88bfcff3f2cbdd71b8a7c6d0f48d169534db546d67ba33c1fd82e1cee763981a43ecee29f8089240e65fffdb3cd9f47cf6fcf6fc1e4b6bb99637db97dfaae9b3e78351800d18412aeeb53f4acf74df945ee67ff8f8d70f1f9f9e47bb08bc8de00deeb537529f3dbf5d2aba010683d5f0e3f3e188b97b3d5c9e0ae36786b32b2c5d77db963a9ab51dbf2c3e27dc4c775b3e3b7e4d66bac72fe80bf2b7f628dde81ba9ffab6ad4ae65cbfe3e4acbd5dd5570f7dbf88dec0a5b6fb6dcced16cdb89b28eea01a5834786a3e00038e1aec0796a1ec8afebceb6020fcf0e8f0e8f8c27870787e786c786a78627c6c3b3b3b3a3b323dbc9d9c1d9b9d9b1d9a9d989edf0e8ece8e8e8c874727470746e746c746a74623a3cb21d998e4c26cb91e1c86e6436b21a594cc693b393a39323cbc9c9c1c9b9c9b1c9a9c989e5f0e0ece0e8e0c870727070706e706c706a7062383c373b373a37b29b9c1b9c9b9b1b9b9b9a9bd80d8fcd8e8d8e8dcc26c706c7e6c6c6c6a6c62666c353b353a35323abc9a9c1a9b9a9b1a9a9a989d5f0c476623a31592c278613bb89d9c46a62b11893d876f7181f35156757586e97d2b439a3bdaab61b6a48f178a55e3bfc0eafc33f8f148f940effffefee2e776fb9eb13f4d0cf74aca65363fe410cdcbd041fb307dcfd67b5dacf523c6ab59fb5461bfd4fd564dadbd1b9feb7461b7dd57e666ef42c8dd6cdb2e58f1f3f5aecbed9da32a7e384312fa1c4f35041856fcb373792ed4c4b5d6e47dcc5dd6719c8dddfc71c737ff66c7745ffecb96fed9877b8c360323b558fd43e55cf56878475f7243e6222dcd9155674a2edaa1695ee2e82bbdf70f710dc7d87bbb6a13308eebe776899f4b575eda97d5a7eaa7e4de6a52b57a574379bb5e88edd41b537378a9636771fdd1dc6dd5f5ce5eee255c2dd63f0f136192f93eb01ff196ba63bb5e88dd46f77eaab2d517ba23a965d6131180eac6686dded5211cd8dcd8e6df314993c3c36329b6dd7cce4541bac68776bcfa3a5b565cfa3bdd2a8476b6983d16c74a7e26e8c68d875b34968fe878f77f7948720f87883b8a3a5bbafdcbd26f706bbc24c354763db49a3774981bb8fe0a36bc0ddd38dbe8fdf456fa23bf5c6beccb3e7eb996c333d7f27a9b9bd12e94a25d6dd51eed87477968fee04bbc2da9cd1e7ee17fbaaaeebfeb47c73a7ebaeddeba7ead9966dba731bd5e5ce6fcf726dff283ddbb6ccadaad197f873f71c3e3acbdd6df8e838eeaea4a246eb4e527fa93d6da5aeb4b12bccb6938894ca95c6b6b234344b6bb9169da8bb7beeaeddb53bce197042f42c4c4ca4e7bc812c588a942629da154575447e31b790bcd7d8857342bae0b95cab1eec24df1744d719c58ff58580d65a7b7fef7582840bffbe2836c1dd0f8093ef759324dce66fe265af49009c90210e7c24ef9dd42d24cfb5a4098972217dda9571f82f52a875ce5967adb5ced9ffbe3f7ea4fb1e14a23b8e045f141df5de5a5b9d84ff7bdd5ac22291b0cbc9eb5ad2c4e79221ca85d31fba9634214197975df9730ba75d4b3289e48f3fbc980b5165005501fcb56a08cf87e889be6ae117efa5e10f5d4cf8af4af52830a53fb56ae126fdaabfad1d507f316ae53455cb09532b4a0bb4fca95693944bcb1fa5059ad6bffaa1fc9726b656ab4f892fe5d2527f3f6c35a950a826d5affeb67648fd45dddf417cac1a5bab1822e07f48a0eb8925fc9feb89a5fc2d9063e862ca7f572da785ada6d547795aeaefcac59477e0217fcac5949ba23c6df57945c3aab5030ff9451753fe150c4319a75a522e2df5a896944b43bdd86a8ad2022df5522e4d7c11ab3eaf7a6260d0bf7a1af2ab3e6c35a16270425bb976f81d528f7710ff86df5fda1ae4e7427a6209ff134bfa6360d08f7f08087fd802d2ef2ba0fcff4d400cb34e93263ce0cfcfc37dfd4d9aa43ccd1b42bdf73c849ffa5c4da23ccd7335e1e1fb944bcad3f2a35c3c842eef41170fdf7dcf050526bf3f0fdf4d459511516e14dd24858a252d90481f45bba858d20299dfb390f9c6108eb896d42015e3255528d7e3d70ec62fb71efc5147145b3bb0bee20ec6cf85d5f85efc72be5a6badbfeffb7e052178ef7b3ac87cbf4be6c7af41bcfad141820f8260a842826720fa8e1bf65e875e23cddbbab7a547acf56df9bd31a113f70320d6ee7f498f71d748bb8165f2a33a3086f89509307e083ef877a55fd460f8812e54457e6544514614f7f1c7bc8091c8cfe205c1614a27e507273d176e097999908fd3913b558cd987ee5ac1af1f700a7b778a077adaa3dcb0cc27eb8c3b3e5c9f14fec23f6671e6b26be5338e4db18265ba2b85cb587fe117439a4f96e5c7fefaa28c7f1f5f3c5e4139808a27208898f3c55a6bad5d1e01f146de77116591f755fc1845ae3ec4ddc069f2aac88b1b7ba41e77c9d4e372f8de8bab4ce258fdcb4bb82ae284445d8cc22fad1546957a31856a5d1246255e32b5fa55f54b7860225f561f7eeac5551127a4183a0dee9261eb7e8f3fa33748ecdd8bde70f272bf2b37df7bf145cac011af5fa4c629fc387db393193f0be58e0a515f7efdd22b7df3bdf9f304fc0bf146ea8b0adfb37fdf7b0fba3c04fdfae08621aa815af5dcc8ec686cf48007bec23067cf5aeb2febf0708cd6f79f47a22f526badfd86a7f2b2d63a2ce382aacfe59ee75def5e1cc5f53c9dfb7e5f7f06effd7bc17b5dde839fbdd79f9178af8918bdd73f9e2bcc12f81cf059f10376800b84d210c230b460041704415c60f010b00088354a80c50135d081171318c3040820620b142d208014388b5f1080e07ac6e2e52c64e692b7b8198ba7b5f672168fe9362901835f9c495d8c734282dff77d98079c13f2f377d1a5fa54eb7b5154b9fcd2f87fadfbdfe3ef7bd53bf97dfe7dd7551f0afc20d85dbc381ec81b86d9f5a2985bb7c7b50e3d84c997ecf95c3abfd78ad12e1d3a112f1884e884012be49d255d579bc99817f00ee475f9343131392d9c82cd207de683605dd631238b97e56accc567b2195926bf873dd767059f9185cc8fcfc05bd008a7f840fc1e47d834aaee7f9714c5abcaba853dd015f342f8e0bb10ba9c901fd8c27d44be2feb9b03f1e2080530c6dc083204cb72cabd12bcc78d4b831f7c15ea6feb957578601f238973dc1eee346178e389d5ebd55f1754f0563df7baaefbccfd2039a75afa532b185e7ef57835f4e282a7d017894a65176bbd2b96cfdcb83d4a881901638c45ecf1c02343ef7b9cf78e5f1fba26c310e51e86289c135223f14b137eeb12e0d278ffb9bfd6778b7f5f0bcc7a54427cdcc2f96b89f7629c73fe72ce395fcf2fb985f3e7adbc554fc61807c11e0ff87bec79f93df16b69157e7d3763ec7daefc79f9734b879f0144df81d3d975abdcfb18bf0f12b7234be9f2948595a7649deb57422c580b0e30cec02f12e017f6b2e7ca529ab414cd84a77c41e8ab1f74fd8e1fc49e7bf8624f93e8ab03f77e8f845ffc000ebef57dfeb970f741ad43b71e795f632e6072be2e5c983defb38c9680e83b70aa2a647e51bf57e5f6d02e50cbf514e0b3eb0231e03339641a77b2c4c2300b1a590673d156b2e0a79cf30db3b058f9e98a11879fa4682b5e152e9f19397c1c38f1ca6786782585e54ad64965c932f9c52bf9718857d020731923a8e5f610ad0031e033f10a9fc99faf4c31e252e215327f0a4b065358525852585cf9514c647edc8111b88eca659e6e8feb341e700c02976967e55cc6982fe9f70b12b783bc5745455505e5f494ffe67b2f6a8cd1b5fe1cf3a399983c523361f2aab0ec6231e24f9931e24f0423fea6fc44c3ef4f644e42cc59bbbb988131df15914c8a7ec6a71233308a65bc8c40f41df776b3e87297cc62ca1fbb425c202e0dfeec89658cb7bc22e27dcc0b1a4993f7862edca54b18de29370b10b7c7dd620bf202d1c2343154dd29592773a192bb5461c25a0a0998b01af8d5658bdb03efc069f0f7e05280c42f6aacf1cb13291e6828573e23cbd460bc9a5ce26b90d9e55f4ba31270e523e38c0fbd10770146181a5380c4edd080e482c4f993057890b3055e001631e00916296000c61a5968f97db24e2d8d2e56d23001024ec044cbf945ba9305be204120ddc9025716e044ca080b50b1c09430aa90b88fb90e28deef7e2e4f0c51f4acaf159f710f638c3f293b397bfe5430decf1863a02ce3d7cdc058e48205b8857312681ff205a2efc05d27c0b85970d6de0782a2959b8555658ab3788c3bc85b25fcb468d18206938f8f04b464c9b2250cc30f5b3b3c166b1cb5f6d1a2a5467a9fb59752f993411249019851aa2aa9abc22fb78a4f912cee5ec34fc64802d696c7bdc8269c5d3e1993b74ad6f1d152c547e58365a097f1d52f3c107d07e84a480155ae574854a2080208622a65c3460a851a475418c2c08420f8f2027edf6af5799e4ae5692d8a3ae7542a93dfa521bfdb03931775bfdbe39237f45910fca3c281fff22898bf301ffe777bc0b8603e05e3f2562ec0fcf7224ccfc8f256aa10d5c2b17037c8efd2e0075bf7deac3930ded5d5bfba2007bc0f9318f3df2ed9ebf9defb4b039fb93cf746f13def2f1858e7b38cf77435407aba9b05cbc0bf57ee1367f292b8de7b5e902ce30165dd8b0b17ae5c4fd86585a90b96f1de0a93274ed104bf9a5026520df06dc02ff08c2d220af545503ef8853109a224305e29aecb845fde83418cde5f2bd98379cf8ab7504ee8305cc0b7850f64a4fe0c810f902a905a6badb5d61a7441084e4e1670771f383b3c76bc3e078b0afda28b1918f16b5dc50b8c06c6e23318523fcea271780c52ebff18f0c117d09a5c9aea039f18717e066e619c05bb30164c451489f0996b4c055b31e39f585ab4fed40f461cc68206162c9f0bcb1dc9cbca3aa22b6674018d9565f46b478344b1cecd070e0e0f1e3b76e4c881bb8165d8c3e90fbf786206c6fcfa03451a905a9f4e7ae8baf98c0c798d35c4173f08de02bf74e87ada0e2ca31ff514393938383838383838383838373737373737373737373636363636363636363635353535353535353535319b984dcc266613b389d9c46c6236319b980d0f0f0f0f0f0f0f0f0fcfcecececececececece8e8e8e8e8e8e8e8e8e8e8e4c2693c96432994c969393939393939393938383838383838383838373737373737373737373636363636363636363635353535353535353138bc562b1582c168bd5f0f0f0f0f0f0f0f0f0f0ecececececececececece8e8e8e8e8e8e8e8e8e8c86432994c2693c96439393939393939393939383838383838383838383737373737373737373736363636363636363636353535353535353535b11a9e1d1d590ece8d4d8d11b46c573597fb99c1dd511f778a70f772dd34b69335d31d11f5c83e8798e84e8d21b7cb9de96944494537addd2c4ba63b07752562ee34c9ba6f2d922242d2f3e85c9198252d885d81d423ecba733b3655852ca5a511551dea49d573a345257a9649659ae4662b77507be6ce22eb5e2a8ba8474ad6b4f5f49c2dba33b2db723d774bd2f3753b245545f7ad5dd574979e46dfaaa99054494d91d224e66e6d5bc764cb28a9e8ab6afb5f3eec08b65fcfee6df43ba7b2bf54ea5e6d7fa93dd1b3a84c7ff6ba6b7746e9f9287a2a95457f6bd7b3e8cb4fcb67cbdb2be5d496ddd960e79b7b2d7751893e5b2a3d8a96b62761e66ecb96dde59efd1ecf9eff2cbb57d32cff283dd3a3937d1c2eee6e80237cc4d162843b5aee966cb6f4717722dc7d8abb0f21c4d00d3d34fc08110de9198244c8911ea2202441413d443d45920c4162844806d248ba91d4a18dee4cd5c8aaaeebded901c9edf6a765f7d139c4876d2b618f5414c8cece876d2b317f767a1ea53d426e72ee2ef3729759425bdb5e57d5f6e6be566c98f8521111cb963a5b69b4ee363d679e30799b96e9993b571b7b9a9fdba59bdde699a4aebacfb1a512abfa1ca567bbaa45e4efca1b93fd6fe3eede53b6e5901f77b7b97b5149e4283d4dd5b687983b082ddb9288bbd7dc6331d0e9caa5363643c99ab66deebdeeda323d3a85f67a034e8e8cc68979aa4a66b3bddadc983f36926d55946d55540847b6f3c2dd8974ba72362bd75d49c4eed874b3a96a23d2b1b6132dda01cd66b0904c82445d370d4bb4543dd933e91cb2635393c4dc4c4e226d7aaa3a227333398d6633221dabae3b875f2afa6d9e49a7f96afbad2eb7dbb6745f7de4c1a53d8b766c6a88d875ebd07db39dedceddda732d69d81d9b9a1d8f1dbc002cf4c03d0816cc1554c00a1da527cb9e467ed29fa6159ac860f1bd82ead6963a9aa5d65dbb2761d77d1a9d6dbacdf35b7617f4479bfd5b5bea1e45c9d9ccdd95687712dc758e9647c53d20dc1d898f3229b80360bd3b77aff9f8bac2d915b6b4b6e9a6d195399c7a81790a0368253ff890c214aff9192374b3ffe3c7df60fbc8dc37d8dc7c8f9d5d0d28a821cbb1f121da49677be6ce5567dba60ef7ab0077377d4461885d6137b09b9999a5f65c4b1d4661470c7c4719e30e2cdcfd7ff8f89fd58ed2333dcbdc5e6bdfb2a5eeb72d2d93ccb4b4ed70c146499beed39692354ada74e7964a1dd166cb8dee20202c004ad8a8ba6e540d6ab7d0468b4af6345d22b8b996e8ee6807a5eac9a6bb65d2d3b22a50cbaa2dab020169d3bd963af3246a595567feb4ac0a040455d5a2749be6790322a44d779baa3620e68f79127d079cdd424bedd9a63d2dbb8f8e76422dab02b1e6b9ae3b09c95ecb9bd06ed5a454491db25b354997642925d39dcba9425a56056a59156829255b5605324f9fa594344f9f8dee21a91212b66827b4db72af42765b9aba244c7a9650b44cd7dda63f6dbad9bdea7610bb5135681f95696984ddbaa57636637544db56ead8752ba928aa1aed545d5a77d206d26ea1543d59f6ccad1b68db4a9d908f9daae9099e104dd33e58ee7a47d3e896bb07c047137cdcd91536d46ea1bdd7211a2ee2ee443ee6e8a22d8fcea4f21679ec9bfc7f00f974a344add146894c54fdc86859f37ffc789957ba51986d657f70f71a7c8cf9c154539abdd7b688864dd5b3b56d14556d330cfd0821814821efe39998671010bb4fa57d64c43102140a95823d7bdeda5f2a42a1502973b7ed99db2f43c3ceb034ac4d3567d2b3ccd1a8270cc6da54938666c6eadaf6f6baa14d77d2aee1f76d088542a566b336dd493d238e290e33776ec7ee154711ccdcecaed40969d9b308d96e9668c491c361e63e519daefc74efa267cbdbb79bfda557da47a828610645491b7b1ad99b085b44d46e142d756caab2e50e72771e77df71771d1f5964c854a3f4679be57aa44bd2b26591b33dd39f1c4eb44c4f223d4ba84e476eb6bc010dcd6645906c2a4a03626e9dee5c5b7696634b251f3dee5efa4842eb6eee25dfe377d1abedb76c8bee4aa36dfe468b4e36dd42ec0a63db3377a2b9ddb24bee6ee3eeb7c6774e15daa97a64e8283dd756288848c7ee5c99b6b652975385cc66b66daa369b9b1d907503b144ebd63129732b5ab66a4bc4a4cc01f1c1a4cc6db62c026273b3f3b16e2026652ea70ea522d8002d6fb4c06130980aed4679b4e55e8fbe558f3c8c7db42cd19d0d2d6d7f6b4fa53f4a4f33ddfd5ecbdf31ccda99bbb993d6cdeea0bd572236f6cccd666cba91d4763663776dd90a6d5b5aa2258d5d2a81f6362262974a1dcb96a82d86f676746e252fdcdd061f43f081a3e7aea8067603b399518dd27366a3a58d4d8f4e96bdb52510bbc26868688a746239321c1e9a1a9b32a67363c3316f6e7076625b6766b7e5dab2453b96866d772a4d7b1e99fbc696b774379bcd663b77b6e96e0d411602ce18c27bed67b56fcbdf6dd9b26fee56b75b575588bbf360c155a3f4676955dbd24c4b2368b96e1d12b4ccadea11962d5121436eb6b6d4b1a7399bb5abaad3ed58a29d2b572376a90462f70cea111ff2110419d81566a6bb65b21d071f6da0e1bb65774ab4eef624caa9ab11916deb581adb4ea231dabb68db76ca588d4e4dd18e2c56b46f62a62d66b4a363d6141915e1d86c6e4cd394f1d0d85a76b7d28c36c46877ea5259a485f1e5e5ce85a9e6600e74edfac775b0ca353d1b177498eb8d705f6e68a3753c1fa14f0071187a3adfeb24609863bf30e816ae833d3c87f93c0f078bd8efbd19fbdc0b5e7c6ffe72c0175f108f1074ef7741c77705cbf8fb5ea9bf1a633de5ea7b71eae2005f947b57e3bcefc5e17b719804c7e08b3f8d2f0cf0bd1fbe305c12eecd3874f232f87247b8f75ecc834508f35de2e2fbe17b7126ba58a7503858758184d7db917f5c10635d9353185f1918d9d541d78844321076ed980157e797f6f0cdee15e0a6e03af6711cfdfad517df346e8857b8177b18e77b6f2ecd0daf0a638c3f2157058c35beb10c134b0853b82b10706024ae874bb8fae6eb18087fea6ac7e7e75fbb41646f395d0f1206cef7bb1abcab9ba9601ccef2ddc91763fd58857a5def5e30a66b74c42e4e7d21bef75ef0ded9c57804f9bb28ac73d275e1ddbd79e6a2447c43f0e220f8047c0236217bf60b733f8cef4a8f59e31230c6f7bbdae8a2765cd1c3d7bb2f3af7de7b63f00f28a2f02d0a5520be30dcf0de8cafbe3ed704cc8373601183d8bbf9e28befec9a80450cea9bbd7cafcecdf775515775efed714fc0a90cde505f7cefecde6f047ce36a7c3d7d79b078333ee1e68cb1c6faf2607c71e0d445dd50e37befec9a805360be3ad4f75e9dbfac15421f9905efe68bba9a7551a8995843cc091700fa62fc6170df518498e8732fbef8de3be3a0eb9c062797cb0c69f8cfd0041a4f33b4b6c4208632050e488282337ca82502176a628c2d548ae1414d6cb144504b45024313382e40254e90224d9c60039f32478ca709160d4ff922850e0a563b745aa92b43c1f581acb60613b2ff81c36a3d3861a66605f338a3012a8f8fadc042151e33d0517b958e270104af12c20d5ef388f0d7507ad81556b6a549f435a550c80013880251fa259481a86c826ae8c91157f8fa52e18e56c15cadfa88b4525e651bda0c280760fa5e3088d23c5626ec388029a544656a1e2f4f304e8c9744dfcfc7174c3f8a0cb10105eb942e22a3032616f4b0c2d393ebcd6ce808f2046b1c7946775b403c16ca60fa3e1d404d22c0d004905d78e2035309a81854375437722022822e64533960f2d1a25ca8153182a8bcf290f400807812ea97cf840b73f3a4050a40adf081a6b00b122f58f482d80079f40bbb862b3d84e0bd524452297c36e815409e1e26d0840b3d4431c40863ac69652b42003098c49d1102a0ac6c60ae921cb9075882ec490ae4f952e14bd6f971219b90229203a614f8b3120a7d627a88a4503e2a21d3c7049848d03c64a96f16c2ea4b893d2e1c1ac0940a7d4e28fa81c9cba3773f18be94d7e35b01084ddca154087dbe1458c26a086a873e8222e1468e14708cb042c8c20b41293c498530f06675a3f30304aa3488c39b65194aa555f820200a4c691aef05bd13e47a31b9e58d104385b6ccd3d38315a64640e93c117244c4095f7a87def145c1b4c28b1ee2b1e09d80daa173c0d464137a6082d1dc6c946774f67470e1600405d4b40a073c65b95245144e10c0c90e4c5824a36dabe160030d32284922045424003eb39d9b570a2800e07518155863063168410b405070e12801acb2010d3cd100187a5a989920824afcc0d8220b2aac3ce1c4029aa8b24492970a3430041c6048680d356e5044c30cd2e88248b551c410a711901e29d00a115374502130030a2b331e190937c45408e6889140046cd826922301f821d2c3841003f001843372b8a8c20151388941898e8c75438ff1640325407ec850e06745942c1ea0000318f1830e0960828921901c01d24305d5ed41e601eea2b97c1a180ddd028c02ef8c2b020c02fc0154192a32f018580cbc05b62257819134eeeeb83a4213bc1cab12300958847bc346081e08d8c61df50b16bd1446852106410feb9beffd7c05936332059874104cbac8b7c25f10074fc60630799e0a4c41044f7413359a049513527c0460d2455023a472b0a030a166d034e413c4f6538544c29d2f957bb0525e0698422c4c376c7882d2c94bd4407502266f0d264f85e3034caad645012614eb05833d3c1aef082922882520d183068209a605d3ca33366842968d357af0580877401f1926fb089d60ca466a68bed4370553163f1c9a875893af56691e29221e0be00c1f8e2ff5e154375437502cd408e00cd9073d7c38f2951e3c2d4c28e074ee89503041cf54309f0d7df34c16a28154247c188c018c018f7822bcdc4fcc9e56e59c7106739851a91c3a8349401060805236c00fbc19d4389a46dfb0841cf304a5c39382e9658a27363e1d130ee9419fa00717d1fb1a3f684108cc18e3e9025a764742444ce9a1b5f043474d6790068d0a234c08d6400392236b70808c0ee818224605892007380108c4b0401712a8e2091a580a06d8b543b02b0e68c08504659051010838e101071b689001c9111788e838818411b6d0c249150ee06107221372a8a98e97139860498e698d1fe8200736d440c2083640608130bce8420211b0620821064084c30c312039f2230607c2d80017547c462002312c50812e2810e646cfd2e8c924dedd3d459284aedc2b7946ad46058bbb3f5b2a91403e529161df86a8e020c1c548c5f111892bde828f48dc1c6663cb9b79dace9d90bbd37c444234c093bbc36abfaa5fabfd517aaefbd69e3db0d656aaed1b400798b98fd69d6ed56ddb5e5f5d770e33a99a7ef9ec396473b3c391ed802c6d24207b87964a96f60b3e6c5bc93655dbd27ec100a3bbc3d0d84765bb85c60260e1eeed99db05e8a10037f79a4ccdcfa4ea239546dc1d888f05787798aedcb7675528ca6d96258b760c301f8f28e288168eb07177187c340205ee5ec447230a604413d8d2ba939e3d6576d2c9a6cf9eb5d94c3d89746ced59142d6dafafc908bd90d47ea6b6446969abbd11938dd6846a42cfc21b912a628b213e16c1c4dd617b09dd6db9ee6cb6f2552576692315edd857db565583f6fa3b865f618515568095287abe5084094468218202443880882088c08d44ec785879eeb5dd313cac4df709abf919984ccdcf18a93521b5dfebbe297d4d46c80b49ed6760b56daab61abba49adfeed46daa36a59d0a0119eab1956d69ead872ed99cd8680983f434426aab6e88edd4144aab99b22c30d36d460c3c31e4955c92946e78e7df6fca58df43d965a73df6ceda9c4de60c3ba5573c7d660c3efdbd01021f87d6b95760a04454b21409e2d7fc8870f262a0d454b20433e8cd49b92105b8c424c71f7177c14a2c7dd8df818441787ad1b454b5b7a1a6df3d97306a6b6fbd69ae56ed9f4e481a265aba6b0565583824022082382f0e1b0bdb4919476fa3235a59dd65e6ffe90ed66810001100d0062087767f9088412103a208c6e7c04e206881b2000e0ee423efef0e44ee3e301008bc5623c6235cf025ada6abf93ceb64c3ad76dc6f0333099d73f6dc8ef14c9cfc058b3dc6bee2cf23330999a17929f01e2e30100232262cf21584da8d696b6b34df7addd914cb699de10b3f92187004c3cfda1b1e64f920188b1b6524e20a504522e90aa435852357742e6d27ec13ccd9d90941f526eb8bb6aee7ad872692311b5dbdce98e483577ac6aee581f88802d6da457cd1d6bd654732714d484021f54e98e88005070f8e16314198ed27309455f6d9f6dcfa2373a6f6c0cee6ee463134e94ebb11b1c6c3e6537ba945b4b207646003a17c00fd5dcb1aab96b3a40867203282470d5283d89d075efa064711fa14ce1508e7087a29bf111ca8e3b9477374f281a8d1eb4b8f78085b3fbec4109f7a61e6e40ce12f580e36c0f39dcc71ef4931b3c21c1f9040c7777a7323e614243f3e4e64f849eecec74e9f9664973bf36dc2fcc08735f562af72bba9b6709b43711a6260e6359dd791a9da82e576ea55acdd4e576455faa260f55e8616dbad9afe9ce76b3eb3ef76ddbd293fdb6548ff49061e17bfc0acfc2ef6df4fa1faf3b5ba276a33d647467fbb2a1a58de8c77fbb511a9a9347cbeed65aadf6b0f2d6ee505b7acae8cef6d5f4f5e6cee1646796d0b544cfdcc97ef9e96e9d69537535aaa1656e6553f55cd39daabab3fd72dd6d8996b7b22d52f73622aa9dabaea6ba7467fb68b96bd733c9f5bbdde972aaedd5b6566b4f7497fbbd8d9efc0e1cf1b189ce9ddd2dd92c101fdfb2e546bf5d6de9f9a4831aee3eea00c612ea020e3277d046d1f305a57dc43455212cbb6db69d900e33eeae8327940314ee43285a0a01dac9111282a52d52997bb5fd759babfae9b9d5a2f295d414e9fc87d9b68efdf42c6fa86d9bbfd4ae5ba7aeba77b5656e5589ece4b0acebf7ad45757bfddfc911127a73b3db84b12ac036929a949e9f963623f56f6ce9d3b2eb69f4e64e77abee957b230f43b2a9288cdd3bb62cfa14fe619b2d6fbadfbf6fb5bdde5ad5286dd5f48dce9779fd66d192c8c36a3637bbdab3e7d76a2afbe66e1d7a98b9d3add395b7df7dad56dbb09655d1df45b96777b7f6e8e85cdb564d5f4d59a3b356fb7d6b95dee8fccdee4adb2efa9a0c8fd96ce855fbad5b6ad9bdee766f232335c79e6979b3eddc1fa52792ad5c5b76ef5bbb93367aa2b699f67674a2cf2aa9285aaaafa2bf8f4adbd9b2278a923e8cd452e6c6963eb3d9d0fa7adba953db2f75bad2c8c35af644bf0664c8476edfda6751f46cd9dfa9ba732a9be28cd499a36fd594894a7bd8cee16467d2f3f7d15aa25f96399cec2b518150a3f4fccd9e4aebbeb5aaeddb9f877daabe59eef577d1af3b69a7bf57d568affbd69a69f9e9eed9f3f76d68b727ab3e6c2d753cd89d7a26ed5577634b9f87d56abf54f4ed167a98b97532edf96acbaac0eacadceb1fc6ee1b5bb2bad2088f75dfda7da4b6dfee746829f3e9f91a7ad8909f2fd19ded6cd752f7e5afaa118aee8c74e5becd76ae3c62db3aa1cd967bb5a53fea106bee7dc4b67542b6726d99f4a8433ba70a1992aa47d093088a96423ca69c08dc5de6a6ccbde47bec5cc9fedeedb6a91ed19930ea401e7419d515a866a8638caa16f50ad50af58aebd49741e1f5b3a77919149e070a3fd3a9cf03857ffdcf78b07f430ddb546d33358751adc9bcdc8966336cae08761f953a225db96f44ed6659a276a7deda53a9dd2c8a9e4844b7f65422425acbdc5e51297ef021075c160f5330c50da5832ffc89a32b369c6c421a3800e4ee9eb201851d478594cad5bcb5670ce5b9b6a56e072569b79051cbaa455a7637c4dc4aaa99f6fc30298da44c4a23b0543ddb3277b6ecfecdeecc74ff129a32d92c9332976e9dfababd9172e59b3b571e7958b957a337d3a3b4bcd99e479150aa3efa4b29f930962d6d4b68aace7a86901c79d8129aaa6cadc6eefe663b6f4acfa3b6966b9baab67d6b8f52152d6bb567f7aab62c0fd6c848dd66b9b6cfee9c6a7bf6a47dada6b268b95367f85aadf63bfc0301e2a36ccb21cfc39ccd9e07101fb39911ba857ce4ce9b90ae34f23f7eaf6a2bb4754bedffbf0e47a751aa0af9dfe8a9cba93635add56a3d0f808719a9abdab2a82e5732d9bfcd2f5bb6dda96fa4c2f6adddb1ecf96c7ba6bb67cfb56577d0527b9ae76ec9791a19edd8f4670f41cbb34df74e3a5152b7f70b1bdd99fb66133a4acf96dd4a8ed2b3dc437ec081e566900b1b5583cc952d081bceb6a92b903ac4a4340243cfd2a856fb74dfdae7c19ebfaabf6e56494d7f1e66ee67cf5f77bb73e5caa326f3aa7d79267dba6f31c8ac9bdda54aeab3e629c39ae7afeaebd975b3bb963dd12f37aaaeea90a91ed9a81aa40ead9b4d92fe0c4937aa060db144eaba73204ad574dd66ba85d475d390aa47d8a4132d89747b23a16849b46ea37487030a36aaae1b55d776a3db445293f6ba51754dcbf568a3eacaae309a1b5036acc061ec5e7feb541bfbe9f9abdada76d20b1121955b09a9dc31d8200457c311ee4cf6919d74b6b632fdb9b1a5cf3e4acb9b90a3f434d30dd40aedb66ccd7308cb641f317fda6d739364db569548cb641f59da2fa46a8f927a24dd45581425b72d2d772cfb8396ad3ab4ee13d5ed4d444585d29d2ac468076d5477ae43ea9069fe30d9478c8c34acf6aaa6473f4444b69d44646edb56626e33dda9342125e64fcf5e818ef8ec564dda2b9008dc5df571061b67cd9da41a3165d8e57c8c01078e42a1526c0d425028542a8624dc6fad6e9bcfda9e4969042d5573afe58dfd9d54de581578a43be93cfaf2d3f359157e3df7afdfdaf67a9a8fa2e6a902db9ebf5454a267d96e73bbf03055f72d939db6ac0a44b6ea1195087bc4fc518fb0a58f4eb509f9a43f48d87da2ba1da41e2985d4a19da41a49772a91563df2b3444b91983fb756b78730298d90ad7a441d3a42b6ac0a34d463aeaa6d07a946433cdcdddd614e1f85aef82824c5dd7f177d6eb73f39b54dcb1b1011d12894c47fb64dd556ee35ddbdb9d7dda61b2d53db66b253a276b344dbb6aa4637b6f45977aa84a46555a0b22d876c21f3a7dd42e6cf128ddda81ab44463d76dfe2cd16ca74e1d5a42753b6889666e16c9a616317f966868b94463cd9f3bd2e0ee381f616869589a9a1c992de72646b3639646453cb21d9df2669746329b99f42c6fb6722d75332570f79004bf9496b91ee65e32c2e0f9f969127685158d4045d69db957b3dce62f99e55ed1f27f761ea945dc5d873be9a30c023ecac8f051470427e2ee3d5670f7149c041e9c2e3ee6c0f89893c4c79c293ee654e1634e087ccc59c347d9093eca727c94d9e0a3ac00eeee4f6270c061ec3651d548fd9a6d2ba9a5bbe86b353b8f424a545bb791d1aee88fd273fdf2d9f2cdb57cf684a1e5b9eeb6ccbdb937fbcf96cfb6b6b266e75bb64473ea6af4ecbacd72dff6b96ea177f71f1f8ffce0ee0e5b2a7a73efa24f4bdbb765b96eddb76979ae65d2ef547d363dcb365585a068290408c67eaa6eb468a79aedf93cca7547feaa1279d8ce9d2dfbe5eff4ccadbbdde6ab2dd2aa2afda79b556fb65f77ea0c0f63d95d5baea54e57fece5457ddafb082da1a199de6b3e7b3e75e4ba54d7b189beeadd4eea237d573ddbacffdbe0d7d0becd9eea337cf210f5bcff6af60c1c7225bf8b6a5eaef906c6a91b61c52b6e5101ddc31c6222c772fff6455ddbdc00b5b6037b6bc3dd06dc1f8c214eeb0d2761a9deb4e7a1bc61774b0736d9f861762adaaae2f3414002e438a04a089bbefa4b3ddd936933d0620883bccdc375b5be672bb3dff8dd45f77516e77840958add5da766bcba6aaad669ae5b72aa46ca954deda67d372e77e0945cb1dbb7bf6bc0d7dcb4c77aad1ef5c99be7a2447349bb17b369b99a1395123a29d44b4122db527926ddf84c46c6c6e94ca20f387c936d3f26cd15d8e5c7b9090f40ccd8c2ef4e0e8ccbd9abe00944841bb591698bbc85d0d174277df80bb5f0db8976d69fef9315dd9b2b9b36d693c070c6ccddd3d86851fd470784142ccdd1d454b21e94e22c2aae64e08c88572dd91ba5cd9b23b770ee94e94c84e12c2b23bcda9665a06e576cb2e09b9bb1759ba70770ab83b175bdc1e1bdcaffbed211df4b16736832e488a326eac610377c75614000550085a68d171f7db4211352099328025b670f78c0319e0f080292a90840cdcfdfe00031d32abe7430a77bf6414d954c086209694c0dd71919e1656f0830a3fe8c0ddb308433ca58104952d3ae0eedf010ad0e59231fb411077bf5b70404413359050818ebb6b04d4c0246e19c09dc0bddd69cbee76668689790a618d7442ad7a64eb9686848800fdec543d8296a74d658b76ec10264543767bae4a66b9571cd94e08184944b3194ba463853811b244484de6673b8793253252d555f73c9ec868afaf212555888e55b2b3b36d25eca923d953571ea5a82e77d288cc74e752753d93d21eb4dc422b9059ae7b369bcdcab5272727272727a6a0a884ee527549cc31858664400480000800e313003030181009c522b1805026e6c1ee031400087ba2549054180ca3244751144206194308300000000800cccc90380084ca1fdcd6b6d6606343bbe2a1dea8c2d894bc4d7a2b58c8bb8e55f87292333c65406c83c1c27310a2c04f64f40bb787f5556b75da370566c810c76f07fdb9ce8d249cbb68bd13042004503de502624a89e4bbc5d66d18ea46f40fac9658de7a8ec73d34cf1cb6a5db7fea90ae7036a1981b2a775bdcceae64e4735163ae92242b817e75f20740c0608b1c7d8c9a3f6be6f731268a81eb8d71449a749bf8f95198bbb08e34004236b130f072fd93729a88ad57727baaa7833033b84ba8a72179c54931919804202469bd10b170d753e7b63d02d6dd41487e0d8f9e458110a75f2a8741ec7d736d7f95e555e31528fcda57149490935256310853d8bc7e8e5d3e5c1d4df3345d1e4c135e55fea4875c5f7013037d2c533bfb5db58176431f82e378d529003c5e7c4ec0cd8ef2dd7114d7eca4d74c72a300c7984f5babc393dee40c1a2064c47cadeae158b1eb8d88153e433f47828785ea6f8bdce651a776c5af2b330cb19c6c5c611e4691555d86772e10e316c1df9ec9f1d1ffe8e53a0905a1de045bd9f88fd9015600c8c7f833dd220a5c0f98a6f0c8e6c51e683c9d625b59bbbbbb1d13ddffd2d1501519bfbc915f7c118d7c35c9291aec202fce0f4980873fd55c1c7c20341e7d8e79deb5f91670b237599df7c805c1040955200776a140c12f00388c9047beb6fabd3e82e5f030e59d7b438f1eafb183ad1d0a75f9fcca18419757bf81ecf0d937b1104cbf4e77d2da93c67b082e6d6a50dc6721caf3a5748bac7d7db25a5a0cc486f940c6769773952a6c7190d6d8042b224cb78bc2e9032e95226467dffb4567a00c17fb889e27e2359b22ea6b24013454de7c6e8a617202b2f28996a11c1b3c99f1df233281dec0b3a213d912fb5725cbe438f285dd31fb7d05f51ae22de6d0d486faec20cd2eb94bc2b07405ef77683f915cbaf0397cf4941ed7dfd5466f2fde276443c7abb069a8ea73dc7d044565338f136adc451091f427c4441c15ec1dd6fc456de89551b8c7c85053f8f656601f47e5edbbf6fbe9ff6ff6f1ffedc1671499cfd05c36110c161c232fa2c19ad95f0968f16793ee705c67b8bea1732797c68156bfcfcf723a215e852332d339c07a3b0646dfadbea2a3e927ed39aed7d4d5cb5818290420a17171c238a23f662fea94fc4eeff8c2a072a1879d948f26522e53a3eb1672a9711c781a3022977a494d1a1308c43c5aa89a1062d84561605e029cde887c11764317c7b0d1a88dab4d304553726505c6f1ccb40a1445342272fc07537ee372fc5ab7f5cb1b09c3b76369b8ee78dc37057aea41be354e4ed06b73a3ecf66dd398fcb35a276971623a9372586bea61202a8bbf1aa90e1fee10f14187b2aa21616fdcff0875065a22f1343c8cad03016c9a4452f11feb0c177f29b69d57698b06c8e345240ea56745dbe5c1f813155d0c14add8e1d4ec7e058f815e5e486f976a57efa3e67624c1b39fbf72b4cc5038e46349bf17b826b5579cc0bf291432677ea85e38c62868ff747537ac50e52f137f740deb6af63676e7f894a78e52b04e9aaf0f3ae882900f6e30e4d9826566eb9971663d72b771d0c223014657aacf050be707f2966c655815e31ef36fe96bfbec807c464a2efb7140f0d2e70410679cb590b63559258ab80288c55a7bcbae90951d4f47db43e17b0856db43263438fb037721b63d1d6d5762ea66db8bed0f2827901a308b72fa41e2b677e1db87bedbde81cd8a2e656dcf095ded99f52ebf6d4213eb364708b717912b0d0eb7b780a3b73ed6816a59eadd43c2521e2761ee0728956be18525ffd4db39b8cc62862d5baceff654fc9d0f3cdede82237a5dccdb6b7c49cfef3136583fd3a3643d3d19cb9555221e316570128fcebffa3c13a6049ece3878fe8eb4ed106256cb3a4281e62bafd34e0fd6437052ff78b04267016d1352402526869076dac19812e928676ba96002b236b19026048724fcc9e4407bec1c5d2d2244df0e8007192b8f61247c79f6917b05a005dd0d39a3a5d142dd0be66cec7f08295576f583dcf8af5c3a236c05728f24ee7966b3dc4fba49522ee8e7a783dcbc1e4213823fd753527d222c76d0f73f9c9795df164c0a010925e3e58c0b61e5ddda80087b5ca228bb9923c6515a75604d02ae4858c4327274eb3066a8de1327eb6db670e1b4bd612c473ea5c233b29e5c4d6bb8233a73b7eae72b49ee20a362f80e78be456207613ce6964b053265aca419aa86e5f1831a14ac13591a2a90e8e5859dd09518ae47faa88307acfed923df7a9ea49cb0e3c3499f2a1a1f7826fee238f7d8f3ffb52a51471f4f816889e5734d3f398877cb2d3ce1a67f5ec57b370f302e74384b075d5b598145fb78252b27b4af319c84af987a4a3c5686d6fb703b1c552335adc10e1ea64d1883f6d83b886c0d6113a08344df6981184a08a9b3d05d204ecaeeddc1f55ce62a50da23e78b0f523a61c26378ecd3f92beaee44c77f40d8b82b8638202423a89a9cd60d9fc4c6d39efb11890b237830249b4b9dcea88d214f30a6c8669ba2e60a99c8846e6b1a8592f5a6d1e264fa9c3f2a26272b7022a23c28ec8eeea017912ef846cca9bfed1df1bc7968f0aa66216588a8c524709bd342a360c400b6fc2b437f98ed6d9c3dbf765bc2f7de252c260a9b819b8bdd27c06a555aff33d2da4027cc32d705858dd1448202ddaf72fd5355ea10a9f0fb751f7b941402504b7440ffc6cb2b0facd6a33859f14edba15aa1f097d39a8d3552074ed310f29a18763cfdde0f11d74b46fe47fa22eb0a64e6f7e3fb2f38f9431b0c26e2b59fddebb7cab553d96a484ef65111b87b57c14a51c95ed3a7ebf821440b7f483a13547fc352f4b16cc9f8ba80691a9fbe326c314cbdf84971f84465429de73b47d1901cf1b18d41189f843df16b80337f6de2b4092fcf26cfa7c97bc1587db2a7de462ec755b9098cf6dd25e5042843eaac8385c5479f4b468635df1af36d15788378832b6f4ebb2d0df50280b05e095f881eda64416cdcf84cf471cfe1bf545f586d27baae806cbc98b154990efa0ca595d5a547317458c21ec2da2e99a24711326902494a7960368f88fac42963844e0f08137b6a9eca0e68271eb97b656c4057676de01c8d23a40886ac35a06dc19247d6ee4b8f54648d3d2c9a2e78d849a2f5d9a9f55248dc69f6d9d5b329b436bfad700a01430ab073288bc455db57e427de512638c12d6db558bc516abecc200f4c9ed1232947bb3e7c5fa5734601fafa2b4ff582184519812d978548b86b18eda0c571c3f8c93e95e90f138861087f2c53e1c4452d46c3f5f15e5395ce88ac81275ad7edfe7b290bbe54412e0ac2a275d6b9a54e32aaa4b914ab22f147ba38a9661b9832723a29da32feb04a5be5eda09f3df8b98fad776e2308e756c106d8db5ebb60a42901c4cd18d71c436820231b0b1311ac52a10c36fe28b6b30ae4d6c0b13402187f566fdb7ca9a609ed7ba857d01cf32e363dfcca7586699a9c0436eb7f486b114f63c3d50637cc01be78bac57dadfedacc17a3c9f3427526d2ce29c1d2580c1522a41f735e758bdcfbc3fb21e372b8f26ec449f9de383f44ecf4efcbf8e9e738985a0e486a73c82edc3c24ae0e15d9cc1077e361d821706dfc04f3bec9a1ef2c35766db7ea9582b1b9981405972e8c2c69557ec5f6068af56aadd35c2f4088b3cc7afea5ffdeb5c853fc2f253ac0d5122a3ad494e38ad018f586854b1a1456cc34a515f0764aec9713d799bc4e4da38fbd42a52d072f9b5afb01be29c63c746d39ac4f8d3ea51ba3504e9b791d320001865b962a507ec145ce6b87e4b14b3929d4a4d3f98cd083bdd25a56f6dc7f5992165c3dca9bc99cb97d6a65155cc2565b62b847d470669d1c2aaa70e3d2aa96e6b7270150584b000f8b5367a3e0a6452cbb9522e44ebb7289d6ec914cd7e9a796e56af55a6031b9be05f4503e9e1f40672d708806409c1ffe24a237f2679f5307e1c70b410c727578fbd70c03ad5e312274983e12f450d428e92cd98b670505bc017844713268361768df63b6ba02bdd1ae3869bc4032f67086101c1b8915e9c9f31d7d0c7f474687f8135619665424bfbc8b2d87c8fc0e70fb740c98f8e0c3409e584954ad602ab0bbf09f903aedfaba93c4903b10ade06860d265ae9a2a16f6e6f6b63de7b644db76c3740ef5641749b889eafaf026b6eb49e1b295027f60f26a712a3363b137837c4de27d6e03e4020db9ceb93928347281a3fc11bf02654eea48f892805e29a8b4b24743f802bbb892b8708a5ba4e40bc96c49f5f357d5bf5c4fbcefd5672702e6af3dc3cc8e4d870fa88d427b0f44eed5519c64ad688250a06611747c4658a8c89712070842796387ab74448e004b06a04a52435d39521aa6685e618620126a60a10048bfbd502097e7447bde70c0addba2c6b67a31581957577249a96c1ac938b7df81fd30336adb6d001a3388e0fe1463fcaddf35b8c2d490342f9aec250aae5b21a5b812f2d87b5c5801c1dbf0cf7e93783b9a63b8a63c7d23d602c7144f4c7bac1fad121b43d4acc755c85b914310072a9493116cbc11555c22f99fb5d8bb18a11fc094ae90b2814d0d65ab3dab71a30dc169351d4c6d7286bb0b0c000f1a75fba21fa298f298c1ea47d28ae0cae3ef0269f83fff9c1388c094b9a5d802e0cb7c0f4e957c66fef356edffd3201c5a0cf76d097f8a811252bf02d7c0e025b90176680c0c170950f05f4eed8187030015504c42e747463b42140d12c0b24e068c44fc14d765698c117e6a13cb0e69d3d5ff85727e77d0d0992a89924384d8d460fbd85d8391bb3ba90b4868022f836a0a0a8367e7dafbc2e256a7d3ecf5ad383719844c71b3531dd4d96d6fb6033c91be18c4906c50e976af4c05969fa4091c3aa0231371893d2271155548766ebd5c48c6f9da68cfc50e1c83806ffe41916c12c43b8ef89317819d2273cb4b95afbadbaa6bdf55b06f491207f6a13b3cbee6c476b2239720cf17197ec7ef9ca3defca8fd2efbbb9c6d67ca26e696d8e1c0e21769bbf2bfc03c6b63efa4b102b4ee7f56a9c026bcdf4b07d990b17ed032b0b4e40c6fa06d0a1efa6def6636dba4d324c5bcb54e354e5a57e470f24945b5883df84d15700896e59a7a16c57e70a1f403c5a123187a3f2e402e9cdec3f913d41ce7f1885837744a808671b0ebdda10f668f544bfc81566628af3c2d19836449f37237fd3f9b466c194d7cc830046a163507369d44e92735414b0870328a764795d234f617e31303bf27572f751e64de61154408f671ce133a0880d0b5ec2a01687341c80b885aa3f0e8cf2a1f7019fe0b3e2e915d5bc4a13b0e27fd1b17c9c82307856079a24980e47f5152033cfd17b1104c64fc330126a5792d27fb771137326b27ddb83ef0327c59ada2bfba9231dcd4d53d92e13fc3d75bcc63b74de62875f950341d856ad377c0d3e5ad0cf2c51923584b3112986c5784878aaa467fef330273f9a7af5468fd99af9386ce51c2d81cbb159fec0178176dff31188f576b84d9be0b0f634a3a446f23e074f8bd08e432c8946ff529d44add29f007d6e8040757e30e162fe1f3c781343e5047eba00f63a6feb2b060375d6e54395ab20950a9c68555036a2ef149dde9be49d9065cda6f224355d12c86c1b907fd5be7e6bb1ee8663efb8b8f14d632eb63a7f48ab754c1fb11090f3ec5f1b995d7fb9cd80b31f756e3874fdd4e113495cf5458e99ace0580c7ffe9a4d575054c36d404c6b187a34c902a663cb0e03ff0a523e414608f2220d58168c3cdff4de1d63bb94909e37dd0c51848c33b15897e51d0b192c72984402568e416995801bf69e520e342dc3f29b14fc004763d5c172899f423bc2302e3fe88fa481691eae58109241e020db21dfe4e7314da88e0d855e2809b3e503406cb9d28eb4d19703c5aba8fcdebc7165a7f61f2aad52667f5761ba51ea70235750c14368caf73318d5c4f315bc70f606b48358da1f7f12969b6052ce48ffc44a8a5d9d3358f4a8a4c1c4b405d7b1a3c96528690ad878d1c635909a1411014dc2a39c3fe8c86c8498edc6fd457b1449d13ec47499fd48fc9abfaf6b29f6a53335fcdc3aec3c0b83544f01308890cf923ab55ba610d8fc5d322762acf68bb9f66bff1565ab59cc21c2319df0e54fdeb03ff1b6d31a4fa74c4869b5224d91a4070000d09303bff9b9c5beed8c2f326c942cfeb228e6c2fa1a813cc0f5f0d479ca871a0e65818461ff8fab287ac47099bb014bb209dc77b20b0e5eedf5165f51d2900d81a398a611c20ef7721b3fa1078dd78b081f6edba62a9d874ea2b79b2128739d532c0495b93cc79c9f47c6a1ac93b7174d287fbbfc7ea664fa61d17081f669fd8f223f38d3d8bcc5b80cfe05207388fe7fee21254f7bc692f8d46e26f40c36a5870b7bb26adca41c0d00196e0cfe7b4f77e7f71b37fbd2f3d812f0aa688dad965efc805dbb9562ef39647abdedc6f8c851559d7d5ed063c3fc080b5c31bc668b7bf1880b907450e39bca986835e924a47dd5bbdd8cba28b24af97773cbca7d3fe1f8fcbf5fd0f0f8fe9b4fb87e36279fdc3f3739e6dfdd976e1a5c157ce1b7ee9e6f49c83d37332efdfc1b05cdddee0f098a79b6738acd6d73f383ee7e9fe1d47cbe5f50ccfaf69b27d86e16a753d83c33b9d6cde61b45edecff0f84ee7db3f1a2e97cb3b3e3d93e966ac73d4e5402dbd71c3df2681b68ab33dc596f21a2bd6cc5443889aa2c2e5ee3037b49e0fafeecfd3adf57568353358df9ccf9b8b8bc1656e78793f996eae97c3cbf9d0f2f634d95c5f0d16b303cbedd96cb3b81858670716b7a7d9f6f23ab09c1d2eef4fe7614d5e4abe8c3c80bc783ceb78b8f18af16df1c1c18320148ccec91c277defa8b83d186e6c7054f7733fc42147233a411dc6f82f1d2f63b7413c881e89286f1af56af8156f87ea2638353210570d432e41cee79a62372e711ccfd785db209f95c018d2e8bcf5cee97e6546e443a6efca01159a70ef9a40bebf9408fee6fcaa2ea62f99b5b0e264bb00b1ebed2bd5417242c1a74ea4172eb8658f39a840710ae2aa30b36b3769f3359ee5d7230a717320332c91caa5b51a930fc4ee438464ff6c12c379485576f8aa0b07cb368c9a5d83efd49d3c6ada339bf2ce82e8df47f905071bde72d69226bbd4ac3781e3456e772ae3c9aa8dd92a48928ec0655cff166533d51132fb11fa731e961d82deffab9e4f6aa3d978fd9ca11a2288701e4897030a633e81f672ec616be2d30c2294e7c36a971761f484ca5a9d4a47ee101b54842cd6f3d883a853231d8bb6481efa7b66d95f61a82e4e92765bcc60401c749c6a45ae278b9d0fbd41dc17736f473395d1331e163b16907bfec00025b7042a319af5b13fbb5d1ae4904baf5c47e8a936391d73b438ddd2d3c78996995be6dec4ad63af9f1f0f8b8f600c954f2ccfb193d213bc5d6905874217beb3bff45c29ce398abde89ec08cf8840df97d1cf9840752e04d3d1a41286cb9e9781841ea672b7e052d112057a15ca404e2865f1e79c4c47dff32b9e2657461d4acab367ff4b12439e4e54af50041a39a556041c1f91cd53716b2b5a79fce43ce33a19dcf0cbccff49ff4c3c4be4f0a5eb0ce73a7b38034f7fc56c39f3b147ca9d9068c6fb7b7338b2d3f2cf22ff7b312e46102fa0780faa5403ab0535398f63fb1fad38d3364721954fe1c4a7f728a8d919951d1f3f0dc3e410f699b784bc2c238ee62eb0544aff11d88e263e13e6adb488f2bf9037e36a0582578a93a678479ca79058a86c261dfd2f03dfd7e25ec84df8f7277f8667245053c9626fad2c85889f7c42bcb826c21837e77c1e104bb6e367db4f58e127198b4b63b89ff12ad0bd44c8aa7c4bf22833047472e2816bd05cca97011a715ab1868b943c5aecbaab04dde431f6a84968a61b129714dbcd5a5e19773e3f64d1ebcbdbd2233d241e7ad81492703c862c6630ab9f02635c9ee39623163647fb1f0406f9ef891055467d0ef0a28028d87781e8b3a981d1c8176058344d3142127ba69f127baa3dd4b30a2f51cc568e81db9c7cb084c267e572399b2d683e79e30ff2113cfe985829c576ac9e59a74a2e07a5e32604b0432c6bba5dd621ae307338f934f051397d00face10864473a1e6554f382605fd154c7eea659eb183286691224bd913e1fa127a5e0f282d4eda07cfe8edae37661c53a087e3d22499903bfcfbb925ad465c1afe84a864e22e493954af7200b3f0bc25c73cc1dfdc0afbd42fbe11411f174a7d16ef1bc04730448dba2ffe1da747bab967e29728d2c777b7a0662e6c9fce95621e367c0cf77332677fa15ef5c01e506ddf299575fcac75e3e3ad4ca8eb2dfee88d00d38b0bfb381fb3d26184210dee797bdad049b27d7ff3609f1e0051637b1e0191ce0ec45a51e32384acd9e2335ddb4fe196c687a5d1dde0139676e11c862b2cb20bd7b44a66b4e92ca66236e951bed058c5ac891ffa8dadfe5062760a30d8ec31f49db4cea52dfa118beaa8c93bae5fc1c2c618aeea6f8f35a2bfb4eaea67d920c23dec7671c717a114d66553b44e57c037de3a6bf29adfa92b8adc566552ec057f79bcfd735c0053d51e672948b7edfa5f838e2bd4704f16ade50139d5921aa14515e7490d7f1b7a9d50b37ba61cb32016c0d7b3bdebd0d9281c95dd46dbe59077e6bd3de6abd2f987bc0ecf2113d7611a48fe876b79844d477da614dafd723d778865a0d66bf038072e674150e5112f46a092472ded6a57bc26dbb91081b6410ee4a0a48f42136a3dd3f8ffbb7f0f06ea761104ab07f00134b0a66679b6ac9ccdc7c2686dacef16c6bc753790058f669cf8fc63cdd4ebe5b491be0a9fa9f11df5f558ca55ee8f584e11b99d6f389321ab6d71767ef8eeb17ec7af101ecb3fa808c04613c7c7c797cf68c30afefeb76bf646022ae5e5005f849e67d317fada0fd84867feb86e47d07e3f7fb2ca943289761c545d3b41d77f2759bcc77a47e2148f8fa9af0bab19c7946f208321bb66fa6912b676b8baff60880943366e8d8b5ed6b77778539296485970a8fa7fdf7dd8fed766e6cba20e66ac10f14bad2d071d493879ce0bd4e273b428e9bfbce1111800e5ea9d766a90fb8dc439270a8cf59f2de6687fcdc198311b665694351f53fec356ab447105834d70a3c20715d581f0d55dd871e4a09da63fb37dcb3ee5de6a0700320c32dfce811867c7f28318c7da6bef337e8f80ada6e5f402b95bee7fb7e487bb8ead338fcd60f507dd9628722de4cfc71bae0b0c7a0882fe0a4e165e59f08d0cfab4f97fd1dbb61b42cd787e476f577fce795e3c0065999443c4de032bcba28b6bc639b7265879ae8f5c7f7c338d11b63ac6b4f4f4e5f2c4545dd812a7e3bc1ba99ffba3b4467000f808c3fb97ee3b9ebaae42edb8e9eb76d79a774cc75fe1cbff7d67c3adc749a23fcf1bdac44b6768fbf160f7e7162bb6b9aaddd076dd6dae9fd4a51ec481b0c0a694fb70699daa3949d2a28c35f11db839fc8b663fc8cbf808ef64ef1a48b6890c8461cdcaecc2c245e55e4ad11bb386751630650b3ef54ce41585d23534f0ac4b2478fee5a95ef55e4fb93f3780732e9b4f7af378669b31b7e0d5cb1586791b0cf6c7e424255c9d05a1efcca4124048e139a15d792052437865301362e933a15495e435f67b0ea31f8c1537e78bafdb88e3cb512e8f1da2d044fb0867374be300f3b0b4c20109c1f5b6cde1ce6953abd45e6041f3ef0d145f3369363f1e06a863aca416b57ee97e540880d025a351e438e1c8ccae11a175f690c16ffb06461598183d59e5a522ba8859c2b5d975f5aed9c84219360a09ea1d00c9315857d3691e42cd41627abf0386bf18ff876a27ea842ddc6181552e90e0673ccda500427b040ef7edd865ccbb19c66d556cca939d17d4e88528a46a263b361d974110c8881e955e6936522e2dc4c001e6ee4b7b4b08f7f2ad0a51a68dd021c6c1f27d00b8c868bdbf3fc3764d7523f5ae404709d17429c57dd0c31bc24e1285e56429a800ef3f4a296d2189200e7604c012062b89e1f9180ccfb45b222a16c076b02f2f37d2e7e75ec585d2ca67f75c063931a4c826bc6cdf468b207c5ecbe535cb1efdb704e5dc368a21d14dcf06de8118d17a15f385c57779d3376512ac7ff6321a1a83f3f32518d1d17b45ff673f46c99fa5247c38b5a5d7af33c1ed4ba352d326711563c954b18c54b429a3e67019968a01364beb155d80d7cb2cdf02915421af5e5e1b99feaa72231b4f4492cfa8242e65c22a1566badc62054c8696c3991a8677f9afd99a62418fb4c81fbe89b4374910f53dcf6c521ae216603c75ebd14c9d03e8b89446e60cd7ec62a5de1acb0a26e9fb82bcc5b14eeec6dfd6079cde347525706e8398dfb0762baa693aa2af6165a67a9b55b7b66fc14860368ea3f96931be7b0b860b71418a8024fd9c5d992ddfb53dd303a353d5ba823d1b929b08711639c416cd56a09d0f4d4413738664ab5bd656b39da21c05d38435ac7793aa3a20f9030d31699253837953a35fb8cb81a7938b94c4624d442a8281d65cbd78ddb58283688709fa1dabe6cc48a2c8b0c9f1986a8c2d5663c1cf17061341313a685b8823449cd1a751d0ce9ed50dbb0e11780de55c76f2cd907232a40a7be885e9d70b73c13e059ace73e7cc4dc68e82563688882cf02486374efc10060854e78d7466f4ccee5da9b66416e37867a6ebbf658642794fa679b0b9bf25bab077feed916a261d87af2d34c55a3e1c044d137c169cb2324bbe06859734bd0280026b7cf32beb4abf5392311009b6e9c7d5d7156ec000643f625690fcc661572ed45a9d40ce0e5eb21ffcd799b3406546ec3ae0560b8b8b6524a852d1bb01a315a1919910231b143f5d599d905e1183fd6044151818c2d7aae390fa87f0129d00d023c4ef3a76c9be43d3111efbfb736b582fc8e7a597fb1559ddd6db58c0a72c7f1209e57a634984652ae9346a3d3781894a045004ae47694541d2a216cd3b58c8d134e41e3a1a29b388dadac45dd9476477cf916b475e94e89a7bc758e9d8b441f819157d4188b640d549d6876fadcc273916c69be44e9329829b9e6ea18926e6e7885c67e553e161d1405a1218b1d900febf53d405a58347780d184547a58e10584b02f390e249d0e1dece98a8a86cf70ebcb4df5b10e21c2c8a5f5cb47b599170877a70feb62f19e1661f7cbae180a7a3f92830c106f91363f927cc6dd32b79cb57eb2c543e5a05d576c81db2bf6391261281b82a25b485b28cba98cab30ff187e1c26194f061e274710ad134db6a0e2b73f9a25ed96b128dd97f870259134d1dc5717dc03a40f39b4888e6834a35ffe1fef6c4c68018c0c945ae0beaffaa9e7383156a9dca775b85ea9f34e90910278a7cd7356053e7a2500f5d0df01c0617c7a726fe2e6a46cb75d173244b93c1e07099297cd943dcaad17e510e8525bf976f4fe4549244bcec3a3685c62c45ff1df875f51697de0e033fce04a76be7adb00db9670314725ad5e8f7c8f152ff24c85910a14ea802e6128ac62992c440ca6be92f2cab7bbd8c3cde3bb4ffd38d706d25492af2f529e47aed001e45b4f8246e90ebaa52d75ccb646ac7fd0511c6c82e2b731652ed97eae47ba8d9eb5408a352021ae2349d4ad94122b840139d0702cd3354415f7a9c7460233681388cba3b8038a5fa1a7cfe091ed555f8792b573b40d14ab0791d4eddac1b345de0b1b4c10d1975b2f4aa938e7c85b1f31300f86a275860c538d7c9e4dc80ec3596cb385c4c6840b8786b0864f5a904d8b2022f1d0d73a1e34c1469a96736fcb69f6770c184dbb23d0c3e1d50821a2643188b710c6616573ecfed4b94efa4ed5613df5d57cd06cdf5dd03b0ae7af7387ffb5e59c09489e6b1c0abddeb7d5fee7f9446023ae58e5d747e1c163693744b10680d86a1b5ee001669429f8ce0ef9a90eb646ff9a5bda41c174b97cafebed9f39c8bdda839ecdefc13d76833132e81b309a6df61e7230173aef8f1bf45157191c024c3d6e3fb92fff0fa2327e4883fb664f885cacff347a83ddff038ecb102db0e9c635d6d260281ee7c0475a75552ea36d88198fbd37cb3ae32c81cc16d62ffaed3992e2f22d5eacd226c5b33108b17a1eaf4da4bcbe1f846216d004c9b1f9eefb4f2ad523d01d14c0eb48f82c66e827ca4911a54e7abf2ed65dee82a86717f363ea85238bd570aa0e4c7110eecc0b7463152b7948d9361db2082112c79d1d8c371e581b1c6bc9cb1a0c62be232469f733c78da105876f1a9abd632750955a5fc28621c119d944cf31984e94f10cc805c48c33ec4a48ab42ed221ce8456e445261a6c4cac8cd90202af779d1cc5bb99f2a855698ff09eb5420ba059fec7a54e40e9649a24992052b5f0eb48a24687ecee818ab4a8eba573f93ec92318a6dc6403c9011a738708378ebf04951c00668b11a9f255fd0d19de861ab5fa82bd158f95df1b55bc4b1135af67468ada509a139900455b0ecd6ff0d0a68934e6dce760435c915c5b3a24d314c7d41519c12438e13a3d42abf12d772834f9fb5f24b8f0a1521354909288af552dd905ed0c86f709a7aa86a8db28f79123eceb784e5abc5a5d507dafc060c0d759550a42fed685d2c01c3b72e9e0f429efce9603d1e96fb2eee9e516dedff68d6ade9772d2d4f24ce0cd2153ef38e6948f54851d6af417ebe5a8e55609a48900a01ff121c0ffe08f809fa2dcc3f5fb756be0b9a3285a3c2b55d0c616c81b82de1f1aac6baa0050a2e929d16e42e8fdda2e8ed626be1ab5ead293d24106713014b2f321d295bf68b87319cc6ef466fd06e879ea1c0a2f9305476829c142adf4ad2291712876f68d472605acc47305aedc83bca73ddd0f778995497bd3f21fa02c445119441244598bf2224ed0d3b5fdd6dfa7a34d590df29a8630c8793ff713b00030a871b18dbec3b5a7a8388c514eec6c4f4938d394f92b96f274cefb1d749762993eb018a45ad0c1fe8a2d7eb2a38e8f44db7d93ff3d51aad4aee5dcdbafdc2e753d1e01c7f267bcb0b93992a812149723086619006c77fce40191dd67597f53642ae77c49fa215031a21b99c0b2f271e18aa375d1d3486a86439baff6dbc9c5cc99e0e4c655b4edbb69c487a91759f9327592daaf429e45dc1b5f20a56415ea95ae12f13c85c0e9c2632b60d94540aae9397468a751983ed8d372250c95012370809c72d668c5a14975f4b497c756e6ebeddcfddbb7c3cb0923c271a5f8a8ff9c8f2bee0c24fcec036d47d0e631e183283359945fda8f34cdd96acc8d5e12cb56b1d057fe0fa71fb7e15dd6d39d66eed8725a1e335b8f4c840ad04d7bd1090c664543014d5e8259e101627b134b56484acf80617f47e2d0948616af4e2e80c7a748416c307c3bbef1b3763d6c84b0ed1e11e6f2f4a062d4c7513c56f07bfa5c9c667439014e152b5850989afddd649b3747ebf3d0e27cf3951548fdc24de4ed4458fa22c7a1f65a4ae728b3475db50c18121fba3aa53e19caa70abc1830d486ac42ffcb2d1b6887b985886fa458c3067c5c1991957dc5c58ee3aa3e1604c6c592e0900b87d3728754b7653776f4ef054a13cba000c8374a04586bad02e44efcc4006034ad912be356b2ceb014e176992bf91d79de8995df0484cfd18e402b5f6c26c29985a7a81bcd31275f619ae39e8e201fa9c49d7f42df214a25cbd25e69bd65cf8f655f5f1df98ad5b6a38de196246a65cef8483033a88185672a920bd2735705e358b558059df68a15e9656e9ff2be19a51851ea0a3ca41bd3f98ec785fd51546303392a12e600072ec2318e8d5a5e3594d49b8efb993b7d5da34f89f69d0276e7b21550ae6653c659f3013eddce3e0cb1da27d4ed195aa5458f680f3311a16bea754b9af34db90aac885e4f41b42bd755bd48a8a57f4750c9234035854aad31e7ab14aa32172f6a1ac404147dbddd8d66ed0f86e12e128c6c8aef912ded76316fa37eafc215c76d684588195b77a451901a4c6ba86688a73bc2eb901db55e4f4f367b361247ac2653a87b71f3e67cc9488e4b44b69b3d7957abcee61b8ce9f0293e27db45ad438a3c1e1a6c11015034880e89d2aee614a7f3352a08a751a52df99bd3c2fd5c3c89a7f8009753dea644e20144f190911e0b015b8a74446d973aeb8f2fd0d96279ba118c50f6c25f2c2ff89abb0acdacc94964edb014fef9cfa3af7cd03f0b2603a3e4385dc34f5c3e09320c483c4bbefe93daa12ce28620c3320a0746129518087598dec12349cc81d2d8ce17fe3447ab2c5fd0705f4247ac7976d8068b993053c499e7891e3b0a34589093c4afd11256eb9b190d0aadec236fe73ac7f2048270f203509650876f596d933febc2f924f22568f1dd576b9f8f9e7cf8dc881656497d25d1998084730c4bacaf24ff006e5d551900663eed51551b39e2d04a00615a5b0bfd22b560df680f428f865cd88841bcd45ecc1389e1d24fcb0c9eb616ba34ad6a903f562f9f31f02b5b6a4714b2f9bcc6f01ed1ea2e18309668954c62b91b3efdf511cdd011e1b94a40e8541adb172596ea5e4b56a304b8fd0c92c63378f514a68e2a76272c4f97d1404ffee267bacffb212e85269321d9c67d66368667d224b9732a94b748da4d3dbe5ed22624997056390499657dd0ee7787da09975592dc87fa8efcada7c55e1385272776d7bc86eeab57a76ffb239f0b83f1dfee5cfc5c4b67a96e2d1b21e98355efd2b340d2183253c4208b158038ddf8449aca23cb0c474b97eca25405568c8b9d7ef0ea309cd653fa1811c6f4612c1737406bef6dc88fac369cb987d67601cf211a8149d7091e9f16e9ef124c4724111867520f8e831ef8ce0ee7db150b83614fb142ecae9bc28c88c59441207e736afa0bacfd8aee1905bb85852a41e53f25b618e47fb76868eff11e9903039205b52ba7207994caa7e636e41651d35a88f8bfe5ec16b744a79522b67a00304fd58d2a30f236c22f83d02210a79cb89321cdad99b011d479e9cf590f2f962a25e7e77c4945029d6b8231de5d7167118a4c3d3c155729c67aa52b94af46f1c53193ad67c7432ed6caec246f5529ce0a0873522717309ebd378c17bd986931603cf6e2c1d3809175e487cfae88c5a6a46a5a66b7c490da55254d979d430f2ea2a054d8b2d50f4c9951ae12d984e4a856d26439246e8c9eb28a9822a6185c59be7abf0f67e9bc00e90b0d1b5bba80122ec25a7d626060e746fd81bb353b74464f44c5ee9f819a3bf7bac57d4ab0d0d8257fab2d62a4356bcc5a2487170720c116708ec975fee834cc048bfc552db698458e630d521419be58cdb8654dd1ca93533eb8720bab8fe9c364d6414fa0404a4391b207c5d34b631472fef238808b29bc29e351769859d224916f26bd7a950ee5254e94e32b9c4a23bd4a11e5dc1a990ab48796eaf06ce1755729f4b28cd3ffb701c0268fc58eabfdc69ad98ada2fab0ca22d9754555492f31ab153eb6f4b4ccd8aaa7bb17c67c9038daf824a69d237f93b09849a0c58c83bc42320905c4e3bec202d0b90adf828e8132e5d60e836efc7519f4864d837305965696eaba2616bec8f24c92eda4c440eb597b95bd972810603fbb8e1e5c598721676d38227275cb83681edf0f6eb0c3698838ae979b8f40617d30b4dad48837fe54d84badd30a65224a8eb99752d81883a138f783debf5f288a63d3a94698492297b9159cf918887c601736147edb4a52279022a65779deefb6c17cf1b01c8b64c2574037a8297f6c38d8ef127b35e6ba928d6a2bc193a0b6d7b5f19b5dabbd9a0dc01baf7a846d133519506bc56bdf48447b8639ebe033ae090c93b7433e01808811d0c073235a5668ecdac43e1b5924b26fa754f357c78d76a47b41fba8d36aa46e1d788a20ed41ff51c0381979408838a474574f3912e792d7a0b1eca345af35604b4cb06f5840a4d9607f202471ffec17af92ce3ff2ca5504837a15252cf073c82aa72afe5974bb3e9217eaf004af3ae13a22756eb38147e3152fd63a1d0fffca9a6f80b8022fe40729c2e8d2e9d298c9200af4112d5bc1c4e2bfe37864436211567a25296448d1ef496da000475b046ccdbb62476b0423496d3d672e4a2c83221d81dae3b8b9131bdffb9d827f1a08e46bf6973c38e526e6bbc424049d11c7929d1912793aba77528c1299c646573c3ab758a903832b2485ae12284aef880c606d18a2538704cf5d2bd097201f73e47af461e48948738c7b7a5506093c2d32b55853bd713a1c50c77eb4f05667091c0546b2d17be37d4a2ba3c371d90bbe8cf5afa54d38895800a6d2582128e43c4408057e33aab01b8f2c93de290bf943a543e0c8aa8c316622f8e7ec01dccc76fefd3eabee0a87de8b3ea64f68ea79d937f705fb8dceb1d0296dc71758e6a06299cf5424445c50aad2a2bb7802e684bca5d8438e11d91ca093add9dc4fafccddde1553f25d00d14f4492da30c9fc2cceb095acfd3f0d46e4a754654e8494418b5d611d9dab5b0219c418d79506010848113d783eaf5ab2683a27ae3faa9c60cd4cb8a89f3fc2daa0fecc1d5d058873fe4fb59ad99cfb8989a558670faf6db6aaa0d0ef961733ec6427866440ca995f9b446a5126e7bf895e0aa5c8b487b9146b389b8681501ed32119a71aa003bdb6990fb434970d79160d12d981c0f7e0cdb421fabb7b98e71b0a0faca02b74902a222ba01c4019808b03ef729a67d7539b0bf4ca73b562d4035f730938d01c428943b654d56d155734f97981ab510e57a1429c0af3284b22327ea1f501535f8e60047475d672435a9fcd42425b20402a62287b742ed482c33dd0eaaf78e93b8485ba71aa651f1316367752971b3a2f1c248c3884212b0ee68d208b420f48c93bbafd373879aa53bb9cc0cb0dbf441162aba01862fbdfd33f31ebd8fc8b678694f19dead6673521baa0071edc67a7c04ce32b2a385a453b202b6e7e9d99873552a92b2da49701f32fd63b5ea5ba5cbf2e0e351af7fe30fa639c821e14ab802dc01d25539e43662c3de7ada60b6a8b4d06ad4d64582f0798dd01d6baf436d64eda543141c6a44cbea57d5c3bab24fb6ba7ba4b21fec3e44937672fd85148b4b7cb9152894562fa1d7cb15fc8614907a0f10162c3fbb12e14c289cbc202b3de56b6b151d522597fcc8e33f3ef02f586dfe6d04c5e1327c53d6b3c759731eb357e870b41a2c6d41b39e51151a104e09ced604fea38c20f4f80202a5fac7eb305c9984d6f136fbcf77a11fff754599789b7c8a8de0331406bf67edeee0dc5310a1316ae15a0ca96c52253974de4c2bb288f0daed9a5edae19482398622f3ca0f1dd6041e6a5f9080e99ae80763cdabecddf870b5db84f91a9327d3d8124ff6dc87c7664f9cb12ac4d5b19e0fe9772d65128fce81550ec740ba2a073bc347458d1838e23ee09e434abad558ba3eeb5f4b3e854d78be593dc421df13b2a438f583019950f01cbaa77d8686e5a6354bea3332c8e40d6c05acb4587ab5e25ffa7ff8b419b9c2374d01306caef0007b66aa3e31cc11e4636e25e5cb7720fdf005a0baf4d2697dcf8bbae79dade768d3f7642f0f892f3c800b223a33017da2ff8281c59f6ca217e2d95d0710c6d03b11088c0b17ed7af98a64c0e07d99552b1938ba7ab1ab56ddde8329ffe70805ae6b8ef3950d3a36f5b3f75001af61e44349e7095ad2f5a105686fea92b64653a336aa29a4b79cf7d53f48452e0b00703f0bd6f4c3dce6974fc6041708213e0f0d703a83f10660fefd8227a77d8a0fbab16ea4fd99d92a5a09158a19432c636128d10162674b2419d4270280927d7362a7533c6803efd402cde40702ed2e701aa4b1670ba371cb84b826c5bc94e4c1962e573302caf57849467131cf011a55ab664f362e7949cb2f14772f842fe54470c15d633db9684824d2f7251531c22fd5d57ba22c66e804748fa8250c74918a1efd6158365ba556411cfda0bf236ed78b72ce9ef50ef15c239401df9f4ce61c3173858b51359d2fc90083a2fafb14403859fb460304e6d57fb35be4978e4a2ccc8c3c9eff5b162c0e66f3d30e4fafd1aff390faefeee3fef6fbff79edb8b8d9bebd9c3c59bc3b576d6aa314698c67252d24d32df05a26bea737c00102e9213e2115c80a27f81fafd45c863771d637a13ae5cd773a5fc3c92283daca0bc2a2174c354840a0f945a53b4f9242d6533d9bb9833e72338fa20421aa3dc028b5d429215365e4339935872842a4bf22aa7b02ef3c5dfff78b8e78b4d41d50f01ef04012fcb8df81ca0442655c664790a677d0b8d4e085151518af74e055f5012f13bd32b6265df838542507e70775229c8894d1644d10554ccae073c1d1cdbb183cd240eb2d604d1cf322f50d2d9239137e5ef0a87acbf47800cd020491c2cc975583e7a00377960b799f81f6c5de0a8f0fcc5fe756dd22e3baf9a5de168922c0d2a6261c8577ef5fc34e9494d4470516340c5ca2adb036bd21bda8281375a5971d2c3d80c3356348ca9da2ad6537374cf1ee731d170e16d372e0f46d77798aa3c6f6691f2b029f9a897442ef99e919f6b86df909e684129c85ac4088ff88cbfa2adaaaff4cf88a409684c06b83536b13ef76681e3db28330c77a126d1b45d27d1cb743f685ef67293426a205f6ed24d9c42bd166ca6a79f0369084abbe1fcfb3459e42671190fb298532c3676a7226c95af73828c383dde687b13d7aa6802d30a93b03dc04dba7e3854322ca2c71d9f3e320ec816230528ee96d4c8760bfc3c945ea922f4aad414283cdc79c92811bea7a65bb3b5abd0142fa30086686f32fdb0c4db29b4f6100bc782e98a79c006b123cd1e9cbe9295cbf90c61cce0e896469944eae6412b4b54dbe3a2beb46c8bf905ec82fe8bb9c02ab2e37bae2150d5ccf8e0c3570814895d92bcd86434e7688482c126a3406cf568eab530ea683950c2938a78694df9227d9f09dbc99dad31a4fbd9f9256dfcc21bb61e22d2443849d88a88b3d2a6852c90b27d3695678de2c67a282b4385f0fdab979385c18d45a21ec2b7fc93a9ad87b2fd791e863bb4840fc469b3f7052ac3553946913a3aee0dca13019dd1a4b48eed56f9bd7c257bdccc6ec11e7fca1b8d6b5e96510e76f605e29b3006992d769bcdfad38b18ad618191095f6992a411c9fc9794c32f21ca11f460667c1d8f863a7961c5547187d4ff14466c284c61900dfce3c8bb988a8e3cfeaa4b2592324a95daa5dbf7e0897e2805e2f14725d24abe8e92c46e9cb89f17a19c487a941d378f839d990d55f44b16f4f3eee33447380a7343a5aa0cc4784f40ec4862decb39fc8616760309d9b5748ba6cf8c5f47cef12e6719c592f67971d0075f9ddbf274a22101750360a2ca692014d0d6a9dbcee3e3903e431893d3ba2780283c7f82044a04043fbd937b5d3e7115a7583af4342e10bcab6d799b4587092f5517ba358be23fbdf367f1eb75efe964ae6088cf4d0e8440817752da6ccb50cd386a9a6d38abf6a96fa7063b769c0508d1e615c65486e1e483c14bff3eb9e1062f9deeab966609ab70900790c76010b250e9222b2e1a003cc90a0261bfeb819c12dc621d2943162af3d7b05a843099fbe8d34ab07a9799fce0e83e08bd7e9e05e1f96055233ac3fdd5d55dd64193a7fa488c5fb43c8a43df5346bacd078e1bf04fbebf7d9b1dd8ec6592d17aa30ef54514efab213d160a8f262985ed10f20065e5df391382d37104a9822fb29b5271ffca4a52b00736e14ed905db52a87e0d95dd9da816b5a62c21f2cf05da4c3bc2bedb6d2a616a726192250820c10969d970eedd41cd668223482cfb507f165b64b4ba88d50d434ba40379dd9e6217fe088b766c679d6f0cdde4861c8cbe620fb374b1163b9a0152aa03673374b11d3b9b01565d0b27ab40f52704fa639cbcc72961b48fac74b0e82fbe5365944bd45bc475276679d3756be6c2b4c19e2ab34a6217f2a85c684fe8a757ba4fdff04dcfb66835b2e03623b67596b47d92ba96a74f0f67a470f0bc5b1dbfdc4628e158ad2719c7756ec2b943b93a5cd216cba2f55c1c2899960dcc0d985c13eed687d481a16ceedc0fb3dc9f39a349ed1281b85d42b3af4e77c9fcca8df98f641a2fd78c35d20dc48384bbd2b6b2b66639c8ab48b424af8baa0a51a29823a1c3080c80585c9540a628d9c027a8d368a72967101e7ebab0b9470b896b29eb84f04503dc54c08415cb96a309153c96b4a4ad8f572704875ce73fdc2474052d6d11a860a880d54fa026b5a55045f3691a8a2ac73fb29c129f0ac2c556854012922fe964e465c10435132b7365456f40cf8ed6f80594066f5e26af66a157fe4d9afe0ecdc79d1764732a7a86c531f005f0c37a42313409b8ee5b28143d3dab29caf909f3280ad1797da0b935adb2ae86f6b339c416bbfddd29265a54e932325480ec59381e66c174074a8da5425581255e12fc1b9a0393b2ce39247a6be8e84d3b59206a5cb6aae90dc81ac45cc7d41cf39e8b9c74d5e8cd9937129958056ea13ae9a582028e9705f89eda25acf876d99e5963df8c9f3ad2ccb91195e8f5fd59bd785b45db827748315782f7a350962a905609d97ceb9cf5b041bda5ba90d83678eb697e37d43c247f82566727cfe32ea7466f7b9792ea02507a3655ae35ccc5816eb6c4a881dcc654a70c7dbe5de0e75038b15cae94bc8b102ae4422109958aff1c7abe58020893f5e40cdc0450704725fd685bc0dedfed83669884f1285c49613a6494a13700515f709a33d3237cf0168ec97d793c8ddc20d3322ff9d106233680d06ebd997895cdbec1862779cc888ab820ddb2f2953734be220f680c36ba167e5122c0bc0968f505137a3d37cc474062050a6c5fc49e8cbd234e475a06ccaa8434f9c739a5a68343099c92fccac4e0a2129d0401966562d0a335c2f31d01a6ced05754ca88e70070229541b86f76acea071884228f300f396e729dfd75902a9fb7b66a5ab0df5b4ccbd4262a20a3c667573c8321dff089b839d6799d5547cc467c59fc1515af2bc145076671cc9b3c79fad0b202c49c47700f6677f6b87e78f4fe23e33dc96d50ea61574e6e9dd521740f54925017770c61faf3d5b628c24303ca109c44a83ff83a3e32cdd345209b9ba518955ed75f347a78b3407b96515da912a5b1da39b0db220098617eb960c4b4f515d22fb4f31e45c3d7e4be7e0020dfabf77569e0482293c5b0361b9e391edd3da596e2c12943fb8287630e41e69ccb27e75cfeaff0c496517a5487b42cd94838f6035426770482892af5ea002fa945aad9d432cb60e13222b48c85d93d21f0d00e7221869e90e3af7e5211200f313b08201933159dce1538e86c085e8157fba8cac46d744007f92290f7fbfe49044ace09f9893e432fedc4ec16541b118c83627634880712a7263b01017c5e25aba9ddbc3273a38933c40f7eb42c72e2a7bcd6ecf04a5c6d97fba5a5967c9b854fe13f3b98166216b12533b2cc29fbe4559d89d4d436e2ef98bd800f482d69150fe9063fa9bcfd9fbd8172f4b054cb7b2038ad7e0eeec5bfd32873365f4f8081eae693c23beb210ecbc82560b07d404d67c617aa467db39d6cfc75f1a3615ccf14faab08dc4e8356fa948bb7483dd2272594b89dc79be0c1f7480095203a6e0ac9ed090f061f7c2bb3e943ccc40b9ca566a3dc16cafdaec4b62131906cd276ae6056939d2d588188a1a21ef34e16e92ada57201846d1e61bfee8e6c9a8f2dc57fa88b600a4447a5fdaae9328f5e089ffc8b4a92c8d6012a44be7b08fe18f7b01707703673126de0beeaf7c5f76b2fcec41718e70bdcc4f13c24fbc01bd5f0fb8c1eaa37803fe4c287603c53ceab171fe53403237ac2379c1426360ae850134e0a95947fd166db0e517ca42b876b113952dc610b8b54990577c27dd34f790fb9210a5e7074d64ebf63ad647fd8d4ec1c124ca5f429de16c3cccd3be5381ac4d65c5520500d4ee14469db2f331b2632d42baf01330ccaa7980b9ad17d89ae80f8b559367bd1f850e27171609c823065f5345b4820de7834bc0afe90501c3d329e56c01d7e16c340776b23e5471d080e3cc6f046df9effbb2f55f3e062c62652fc104920ad3b5d0229bec095b5b19601583dd48ddc0e4afcc388f5f2464bc56207e52352e13401a66aee7ec08ae8d6fd20e39b44ee9d0e81d9159d871e4ae3963577a480ea305035d7de3d42d8a14884e2867af97079ea523ff2657682183018b7d0a43153f07604a82a84dfea87f01811db82686b9ce084fbae3802d98b773e2b905e3a4f8f714881591827974c6d9001f43e7b2d14cc9636dd34bad2e6b0625c877d08350a5793a0d3119a8f937ea94c6de8ac817e75aeb3dc53059a5748c727060c2e3d50750f25e991be3a78edcb313636376c29b42901397dcd1546a4608a76a18b923b28a36e9e74fd5caccfb7f4a5098e3bb46e35a87ac4aa52ce4b79948845df5b057627b849b6529c85aa38b046a9896de980e7f30a78c6a05f6806e9dbe0e43984bf074bb855de47a2e742dab9249af181fcfdcfd9f1e5bf6e8f609cb44f469070a9d2d70ba0898b66d66cf7945962979d45edf98f703ddfb1ab451dac64861ab04b07c54419949c9e3b4bbc17a53a7d13c445063d8ea70b1dcb2c41f4a14caff81cf4966faf46f72abb05c52d03fb2d928950ed42a5f49056b2353562b9fa441bc7ccd853e08da4b104a917b209a7ae1b88061007c0ccf6314a74e9eca9987f9259293351a75e768fad86458d3242e2d8788a9b0fc7cbf7af68eb478f110ab385f2ff42cf367cf8ec586c2860ca5239e0351eb5772f6aa613a68de90085d0db214e2ac16b939c484418b0e6a095dc8847c900a663cecc70424fea043894f10895b8fbb51e32dec0332aab86654d767743cc3e6d07ba1b3fe2bf5f3f82dd16feea0cd0e3bca2e9110da00f90dd5ce4a1cb90315ccb6d17840f0b0d709da06dd33ead3ac4df111cde6137aa8b889bfdde9a4f6a22f865956ce031c5ff3ab37e40123229682e2c61bbd708a018cc3796fa8345c1cb55c5940bf665c661ebe5ad9c430c7b8419cb33f3a9250e25abe4a097ed9ccf8b014cf7137aac167d000117e5ff2d4901d9e9afab274a8af17f2fa636ba1d91b35e617e3c2e358f78b3cdb8f90d7662b48a8351a19798466f483504e21083c82e2eb8bf62eba60a55321db34d8b4c400d0e76ce49ff8413c2b760840b6caec8471fe8ec6c9eac9c5c4d56ef4b4028b87c5cb0e1190e906ff3498000730afa510f45d3d361ab90a5da892a57f81b3cc5717d941a4040254d3ad7c591bffb4eefac5e4da38c7af7e2047226e29e1ff4ef2f6be2c55b688fe03c68a490c6f0282ce3f0071614bb1b804c2790c084b7198a5fd80c78d81193b462cb30a4bd144f0c0273f47708ea568c6f2dd37a76215eda730c2ad68efad60a7671705a5381fa09964d2d1943a9eaf90c401a69fea26d3d67090600f40cb8e86ed8052fddcc603b73b599e1f552d420bba031e09bad8e2b4b4bd9e88b20f78ab60abdaa85e02ef5d09fdd1c6074d32c128954c5e6361812d001e706ee4714e3cb310e3bda393ec0b9e9442a53c41ef4def0cc5e1a6b437c21250b615eb8d0e1f2ef10c84df385c506159cc944197a4473059425e10ceb0cf6610d1b356478e8ed613b092ae026172c80313f4ad86ed8742e77c54df4db92bb2e4e02d07420820b1935138612c9464090999f1c70825a648238fd0480f570a61299a7d72349ffde930546110648f61d8d2c0a4beee390dcefdde99750f2ea9c57afefa41d0f48f0f230be58ef8480e65e36a5e780c8f0bce965b67af5922220363b01cc9dcd8a076d8d8bf13390205ad4521bdcbf0f5fdb0890f6c1d2b873c6fee133e754f8036cfc66b30d113a1103c8e602b8a610646ac48ee53e7cd55dc4e1f452d3b82878d2ae2e15cbf4ef8e05dee060da22cf9da4562911ecd19d607d290030cc4fa26509d109b25a90140cf03c8cc253783f0900741caeb4aa943d89ee7da2102db48e3c18dffc7ae7211a2c35ad96ec9c6309c7d9b2bb32fe4ed6a896bcc79bf92f9351573648846eff65bf79410e3a13d5dfd749ce97ec6860101ce298d66747ee034fa0f1bc214bff4820bc51b0c1050a4e86fc133eedd52f24dd1ee04018af54691f95cce69c4b7bc9a8c49cf0e72f60334712766d4d4ba6677405eecb7df65cda4e16ceb57aa23cdb87900a64060b9c0843debe6d451cb27470f1db8412e1d1782d08ccb22dc3a341db1d757d3cc43c46e134898d353897c17a73068f0a14458f4b1e78dc94dd7f17b4b2a08c735591aa9154169e0a596c4730751889ab39c606345f4c3a72905134f4ade7e5ec3743ac3d3757d592fff9f6b9ede2e8366e3e8ce5e9f3c45b394fd4f5768ea8f3c108525979d1ab4dad7454c3889dd8eaa16ed7b1c467ca71562d4092e79590cdb2f0f181fde68b9c1d70d4ed4db1313e918104da86df91eb751643bc54580bb35512920512e7ce3feb970cb87e6ec7702547fe24085b0dbcf3c895a0cc9648f97fc3bac52af68ce6271368a3ca7cdc24e2b42a0d247e56356ac08f358b898b5f33b2213f14ba09935f2887e433aaeaed8333f9e3548b89f3168dca02cdec5bf72e36042d1abc6ba9868fd4a7854bd213c8884a77b2ce6ddf1cd92ecb8a150fd8493ed73e06cb924ce1d43ecc2e545b3a2b342f7668717ffd0db108a8664c2894eb791273510116d1c8da4d0a9720312a2221827d2469ed4828c68c7384bd278827c000c16a002d2233b224db947d97fd1116c998d67a7cce481cb5fe49355c61362e44084470cfd5a24025e53b2c59c8f2f62d6def2c22dd1e291f833a2aac5541e418c3064c20b9e9e9695106934a2fee6ae05129df6f7b6e44eaa4f5d1c0f1241721d5b680fe720743ec728843532f1acdb31b0cfa3023337a51fe7078904e7c1fa3d99bea694be431e849f2ec91432b1206a744b123297a468139deb2362f4e98d4d7d20282c515c4560ae2307e1538551e77d663431648c1ece570fcad57412910d0b77fb952392c9635eceac0fb9b80642729050e978a7e8a35f9eb357210b3a57e602a879b5702c4fdba6dc15049e0b5642b485fbb0cdbc103c501ecb4b44756a79d11c0b8e7bb4d6b24bbc47b9cab9ba7f44ea540f2bc1e0e589d171079c70092d31ca9c159aa3f1fb353ee3e124e1c66e20baaef03b39c4f8c46060fa883d6da876744c2a4447a2612f53797c1f4c199450e5fce7418b68a53d13647ecf3c7cfe3c28b7be88c98b19cebfba2fedb7796f8a3b3c06c02ee045b1be6a36e8cf03f59a09f447454f2033e528914d0c09f744fb9d92885f6c0e0ade704e10ff125667a440511be02e3a8e0357a2d8a65254b3cf50163b77f824ef25ef2d709496d1673f7f2015f18ed350fc196d9ddc6f6dd0ef81a3462a56addc507191b6104d99050989faaec32149982b6e728def8d624a9e68285f2993443fb74d7fd7b122430358d7920a070b5edb98b4c6e434b56060e53d1a48cb1730165a3bc0b909a4bb9114e310f891f93e54679d24e200e1b9c0db3d788fe249342cc4932e3889dff1926b4577b6e26036c788330e12e7f471d244f72d51fac271f9b0aa06823e42da9d08dd6ebd4fe35c4dbf49afcec58a37c2920a49142ddc6ba0c184e86875b2314c881f0bf946233c6597d95a557f97c65b66770c4badaf81cacdaad88d9a30a3c9e41b0acece50b018920bc1c14d10aee319fef046c36bc4141d12887cf1fce7014f54a1579444f1a768e820d2db0fefc18783fb6e5c0ed147425b535354c672c1b055f3255027e852cd9a8a288b4104d213e4a4166adc142b62c7259781f0858cb8a902f06cd24dea0458c83742d53666dae4019c557228aa1202ea3ebe11b3437cba11bd540189bb9d7263229579340b656254f1fd6e6ee091e2bd99bf031485905d5d455f6afc1aa36b0cf5b0f3fc407fb6ab863b3f1aae43fcc9a1f15d124da95d6ac1d7d63c541a6134e6168ee4066f89079a62f652642e948a914c924ad34e41aef56d9debe90ab38a9b38b1527ef5613378437468c18a3ecf2616a82e3a175c018ac7d097e417d97eba69bf5a6202466b39c1eb05c0681e8ba61ba4d5f2812f28d323352bcc136bdb0aad48d3528190c641505a8ced615fa3f43dcb2f199933de8250bc8e9de5263adc18044d5692d0bfad75c4964095d5b253619e3005ef53dff1558855435de6e7a0478e11ffd571d6a1c69130d4b9a98895e186e752ac9d1693d2cafe5f91b7f66d3106c3e2aa3e23b20c1bdb5fab7601a7bae598dd0f2f845a60e5215d2ba36c860417ca7bb7d6840a41c309f3c106804f790620aea0341bd304db44648c4f2ae4abe3e241ea4928d183aa4413ac0cfc1e2aa6528c37e3d3e32ed5a1f66890ede1e14d37051e39580bd8c84c1e8b646a9be64a2fb4c2b8eeaf3550382568eed19876a7ae6fc4bd4cb3f2b9562d03e2f0dd55a07f439856d93752f10794db280f7a8c605ec690f52c80d39a78551a11c0fc921fc978c4407a92181c1baf375881da71d980cf27943fb9f8934e45d3a20baa06900592357259786bb00683eade301b151679fca84d9a584c7b688455fed7b3c94aeab671bd89a31db245652108992d049e3ba042005688f376281608f8ff5935cfbba42c10ca1ee3b5b3b1aaa8b0c9d9c59c624a37811947fe1d2482f5bc8f27420f1e064a8795c2215e0f13ca574cc8b59e97c87cff4c24f7549815c0fafc0328cf444a08f84054b2ccb9566501c32f80d1a3c500828414fcf456b12fb6fbb798403835729160fe437cb192fc272f8272474cd5d0747505b627c4cff6f9f681c97870ed946560c235cc0d0cac134cfeed59cbb9719240125af210e4c9c95bbd02245b63f9ee6191aa18d89fd71ae49ee800557ddf041f2d85ac53827e3fa5f38805ba96615a3029b6b73a20a646f07d2953753a064cef273a5ab4066fd5cc826d47b5ab42bf63164411232ddc62608d2bbee55ed3d2252737653af245a6349c46ab16d9bfdbdad343ce6ea5d191d4089d5bc2e28391d99a6bc3cb2e6d99e927c658a7d880ab6a9d38879a1f57559ec4057bdcb4bc00c1b506b6a88b49abefe9dfa2e09e0341c8692b224d1b4e079c567befde073531f93e9d550242c9857f5418f1b287e92fdfba5b6a1902dd97589f98890ef7d9e5b6fa74bb9cc1a32b1ab3d7494021d5465b2a2ec54c44f229de41e2846c328ecdfd498d906cb342a28705e36addc15513a87da609b020d12b204f3de67ef350ed8ef9ab5c7ec1e5db8d5201240f85f818de519762708f05b379d433271d0cf2bcdda067a1330a216a52e510d809a970d2f820d472db3de69c9e3fe17fce3d74876be913593dc0bb13d1122e0c19b60f499f5537d77b22f86e9a6a2399f6ba546ed0bb43981ede519809ac2be3464f8458b1c6c6f8f2ff15ee526ce6693f714a5c22a6894040b5c8debc3d1d5360c5855b55aba8b2fc3472c753734b7d506be1df2d5308b9580f4ae2d54c4a6b27ab21bfbf97ff145ffd97a75c4e70c9d9ff81b54f3ec86e9f2a4f496c96932d9e1eb7e01e842cb67ebdb8c56e11095270613966b57a47a53324fb853b3a40b8a97a8b2c0f69ee650a1d787b42e32f48cc4fbd4614ce3072e627e1aab394d606a4a040efe1e72025c7c5668b447c0e1dd46a0ecfcae4278ec6065900c9eee8ce9a1168d652d8e7e815b540c6eb5f4f6ac028b5a043685bea0a4c5a1facf566754c52b5775d2b1df37fbae83c282dc1e92117b6aa030a3b6fd8c7523b4bb95322d3845183447b8ad475793d655b11048a98367daae9eed2892e7cf8847cc8631ecab73407a398f22501e04e400889b797242fee26a99f3300c036f5a78f7f0dcee4103810e5752e68d2c6a149537bb463d549543b5f578ce4051c710ef1ec883394711b4cd8cc488299b86235ae9a1202e8d35c3ce2249baf4049d09569141efb6a60a5b15434bc230ead00aaa9dd74a5dd0c1a31d703ebf9b8203ff1f83e17b1e0515fe9ec3d82cd4fec5248ea0169fa5d9d83c0236ec399df6413853d9972a46aa0532806a432d20348bbe092ca9251f9fcdcb18744cba861a52b2183ac80e8998308077a205528ad17723e07f1603423507eef491b4bbf016214591d46cb77bc8e046f46a2fa750a4f05fedea602c4db4b5cc32b2a514c92eeed82eaa0c203accb0fb1efd5c442ab906cf82a6ab5b6d9d6331c402d31064447a9a3ee284234b48d28590b3e91f04279b807171a67887ae4a8d484579b5f3ce10b39478782344e9da82f6029fc0e9a8f16e4ad9b900706a02db9907c8d03f29ad62b7a5cae76601c7aab22c2c48d4c57c1360a8a72541bf6523482153d4a18c0e440cc491097ce378449d697f14a313c3a7f24e5bdb9ca38a8a020b6faf3952fe1214db67a32ebc9a962c444aa489d458b76699fff229a976423d91d31d584116bed42c6bd88125eef4553a87631e9d17329ef4728236bf4967e6c0f343a614b679f40c76b5c5e3900bb3cc59e387bb83066df284399c84d70a2518023fdd38bca885a0995a0e0e20ab7fad4bdc9c83091669f62c242f78fe442d79021246d22c1eda8f286d2bb2d6190492cbe7333152e278a64ffff6bd463e299fb55a712960998ca94e044fa0c3275e30dea3d0213ca54cc0c83cc14a89e3c0a3e21aada5800c3f2e2fd017629be661b1b673bf1d0464c9dfe5fc9c9a56bfbbf3add2ac0d31b27394b517b8aa9d8e24d1efbfe17a9d6bb0ce07fd52f5e672c2397ac874328b6b53fe161ff35ce912932bb49d674a2faf84b6443862a5e6aeb200cf19ad7a830248da86e6aa736757c36ecae6489779ff0ce51137f024c604d1c028513349466683fda4aaff6115f930ce3509838baa5e2a5b39c1076b5cfdea285d64ecc67237e4176dd5b417f41b3018ca42b4f168e4300d5cf6f808f1033a0c7a62ae25fdcad08d0f0c81974c30637081e5c155cfcee46f66c279f3486981e7f3793260e8610c241a1f7982802eff993b3c6ba1d318d8a483845d909671a00b102d8c769f6cf5b9a77e2bdce41773209e33075d96d4f8e331d2ebb1b700b9e9b638f11ca0e933570baff0bd267127d94e37875549a472548484f4de473cf2137c90f31d9ea51434964bd614cea51ad89fee163748575155979e32412a1c4663c7dab5341edb2186c9f3b5bcd8af5b47ece5c4cc081f1500a488352469790dbe16898374e49b80bead0d1890d8dbb36eb74efca22dacaa16719a6492397b2326cbdf9e326170e4bf9e0d7aeaa7c0378f15b893bfb86e794e14d5f1d3c4f7737d505f48862e3fc8b3520d48069a799ffdabdea7f518a50c9d33cc4347b228d317c8b9261c1df8c8d9fc285a910791eeaf80855bf8eee4cf830ae4a4954104b8c67bdfa61c62b3129c35129df5a7c06a8abc12bcc3e65bc9f1e830bff70eeed89f3f5bcf7628bc16d7d38763e9a71de98ffb4b15d70592b7fed5a98f451d5766d676ed7f2c5a1c35d3b68b1b2cb96ec320f9be29aebc8d65811e25abea1afa6ddea6b8aa07ec283c6b268e78bd3ee662e178ce7b9128396445d99a1e9c401323e795b67335bf29f388a2fc21a2244f4e510903a6dd65ae6009171db1752c7116adb39c37bb9053da1204d552715dcc4ca0109ed0654ea27570b022cc94fd094dc419fc9b306875208abd5dbb765ee70033b039625e1128d329b5d2645067bcff693117b11aa42336159ee3fb74e2d1e054000db6c1b3935e2903027fa2488bb3b1fff3cb0e12c919c1b55da324fd9cd063eebc00620b1ac5cb00a94e8b8110eb4f4af5e4164ebf7ccf0cf3579339681c71d18fc93c81b6ab80bcd0f06475a807b1e3faf8b1baaf629d3f8eaf788edbe48c21eaef28affe646e3a3efd5637a2ada60e58f1f079e18aa85e4e46cc2368169eff940a6450427901fda1ba4833587e19bf648c2c4dc06b14b880a060eaa8f31921e51232d27e0d94282544bcb676dcc5fad61a4f877b40e08c263c2e02bf6537be34dcc9074e435562a91ec08102ff880366a0c91173bc1164e855902d6882a87591a0411618bcc4a0e1e6d409417a9c6fa81c15518a18ec8ece47f033835df1500ff22c98e87e80981d4b7ea46003252233c74549203c19b1716ca5f23ec7047096f87ed9a1a1c110e9cf8730bc4f9bd2607c917a7110cb4e4ecb98d157bcf8aa3dfbfa6da428b2cbd97c205e964ef51b5d22aaac6d75b73affddcd9c1a0ff2e50c3a675712ca941b6841d4b338faf79695509c1e186d203cb93984b138fec87171383bbd55f62c94a261cc52c93a0fd530657c30581ac32067b85fcc634ed24a24c416f64bb043a1093355751fbea4d266cddbb95f9bb80c33fd0089344211ff2764f044d3359001205754c66836ecbccf20bf0863d87ebe9ea0e2af01d0ce64fd92ec495a89ef14d1c98e930055c1ad074aa3079b31758415b5febd004ea29dd1121a464f95dde26b0c17f06d087abdb4d119483336e1915bfd27c91245f01f78dee9c417d858bf4d185717f361067a027b65e7af1d9547a6a69d4c6bc3872f74aac4c0c3df060ce649f5aaea93252edb43633774204c3f260769064dde581c25b64e22faf0109a5cf05e4bb6a9281fb8935d5e2a8030ec5898f367ae07e33b35e293e43e28c626332f59926c5418fd669d0eb4da9a1333d7f0bcc01aae318db27d3bb6f6b927a7f95475d9e49c073168c377ea2e5d2651a502e32f332c647794d7571999e095148ecbb48fded8c80ed1fa290653eb940077e9ef01948c10330d8b68206bc374204428b5d95eea6a31a9c99ea67299d597d2afde7566c98f5cfec39d94d38b3299f1cb6bf28aad2542a659dc35c90216a50ff578350d55b0637032a9a38a8acf141071c50da7c0554bf01c3c109d96ad23fd85cf4b44550ea6bfce41bdba982c06c2c055150e7de6d13b5c2af5736b8330fc0bc7888e214e3e683a8312aa1cdabe08039c0892f51b419b7a8f10a47b10103ec078caa48dd5040b81765a9df09cee0ee5723972478c8e2e2c81336a00c829d2271cdef30645e1431217800f54d92c05e2164040791b4ad6f65680ad4555c247a6a6547ab67f839aa89d632d3d52ad8cada920b52264af01a09001160335eb51543811594e1965c62a22fa57d214e4b334d885d4d58e0b2f29e3d4b0c19ce80f8740e0c0e292fd1ac82808484d3da803364b2abea6138cb0c0bd13b06b3cdc8dc995802bac5c0a6e50f54c15624a8537ac5c81a775882cbcfe16653ea604a3f7656421cfcbfab5d2c441a98e28d4ab57798e5a55e0a227ab42a6d120102c661c347dc8c32497507a0c886fc34845fa0a1b789852bcba461dfb9930f4978a4ebbb0e20bfc0cc0c221f159c6a7980fc4d4fded412a88f9d3c1047f224e601213616225a9e0f491ac3239affb5f68c8ba2a50ed7cc4a40a555ed4338b6ead6cc03df3c4d0989ba3ffa0ae74a2a28993ca93b4a4df6494401a7c767cc1de94ecd53a9188c699bf5f527080ab52645de2b89e7f50022a7191a23176281ab83c98c26c1dd87855cb7a576ad8f46c6e69f6b7ad55adc366b09cf9f692ba02a546b306748dc1f2e86742ef8b8f6e170691fa8f5a357b3a70080e350c2ade788cd67cfab57535a64bc32f0150e68487f54d91cde2674db3db084a6d1fec20edb6b804030bd0e3328e059ce3523e5cdfa2ea1f2a05cb082c4aeabb54400e523f909b53a74b4704294ff7834581a07605644ee7d22f8f17d422b453590ab00dc2b0d3eafa4e3aa91d8eafa61f39121d49d87b9485a602e909a203a98b305f94940b8cf09624092723ba9d368a99bda1b5e9c764a7ee12ecf0225c4d3c04d8ca33db2444b22f19e7a778e35254346c741fec623a69e65b9910b93e0e7de155a2567f23978b89d86667dbd91f4db4e2677a6ffe42323409b0bd59b707b4fa9a7449af1ac328454245745e436e484ab4731955c1d0a56b35ce4ca041c645fb900824a6283b70759e77040ea84ba521569e0f37330729e3c30b77404cc232f432e4ede4cbbf11912735993179f3d958f9e3c401ce6d2f78781e2c581aafb826afb24d91bd6a7d167730b5a7b6fa07879a2c50f696e933cc2eaeb829e46957e4da04b251e93f2834e4e1125f8aa0a73d09ae4ad9d4c564a1a1fe31895f75664912b0d63960992c1dc148214e5698d0e65a840441ef9c32da60b46ffd348e8d7e8baee3f14eb7fa630f17638aac8cc5dff0897d408874ed034ccf4af5bd95868a2d0459c75c817e3304a32288cd7de7f41c92debc87218a141a40a85eed130b7f12bc290d0d40c9119df7255d0a2ddd46035ebcbaa78f8c4f2778f69ae9249fd2d07cdd71888a274527356f4d0f52da57f2a375943b774256181d1211b686842cf6a1b2a3231b2159cbdbc2c4f08a163a4ae91da4c623402ea7fd3c6daf41b270fe4adb33cd9d1df542124a40b4ba4b331c62d650654c80df9310e421607a7feaee5f3745f203f839f24a2f8585d13ef2fd2134979b4aa5292e310507bea0f1c1f54dc39ef968f46b73995060f0deb7c85d013a82013f4c45c93d9b57806fef55937e0a216696114b210737357acf187a6501faf63af3032b382f6b6ef496c2a414aa18de1eb29748c37792e10e87d2e57b1359025b4942cf7076d0b61ec1fa6811bfc83a846d5807c219bdfe632b501c675a5501770b744b3adecbc0818f287e4c1444870fc84a9367f6666613a6bf664ebc908986148662014cab1931ebd86346bf461c0cc4dc5bcd2cc61184d72fd810c976349889376f450c574db468e8a31f08f1e6c58f2f84d7ad6e29e35c1e9f26ae01ba19aeb2c422a2435b4703d61269780f0d5ef9a195ac6278d8d09e9b281cc43d74c6b924b159d3b1852e584c7a08ca29a9f8aa5b6cacaa2e108a41e3254c1126af0b203cdcd23e5c6b255b250c319e7d8906d967196f9d4a893334c998e29a7ebb96f8647381484958372dd0531df89c58016282e24c0d6e518a930973d56b585ae5d1873ca2db0ece18e10ada83096524e9a73ce765790ec6b270012c6bac7774289cc1cf5aca75818e4ebb4d43f123fd905556515902e02c9a391f078098f8cef44faeb02068bd06e027640bc16902ad606445aad8533aaea87f63963c86243491d453de8240de8a9d55a25dc699f7a9358f1c317f502f166ce08902aa68ffee18587ff67bf0f0f583ecb3ef69ea9f7e22e377dbc6beb5dedcb06403ad827cc1d6df3a26c5fe9038b70297f602418d8be5b982056d6a20385346f0dfe9f91c5c6d5eba712894982a7c16ecf6e50eaf969dd61f6488cc39e2e9eaecfe01511447c2f82f70ce25952fbd644741a2094314c291338d49610190f1208e7212b067879dbb0bbe7f759ca7803f79871b20238f593ba4177c15c82e7fdfed298f85a060eb653c6b894b84485e696f19e8b6f483aa1ecd6cb781089daf6ffd283d641064bc3715b1f5d50a4ce155aa1265b587b01bfc0f11af6491432ee43e69403b69e96776428face22d92b0048294903ad957bd8d05f6b1817069b1095b5538e8096649d2ec35deaa9d557bfb5a2d0df799547809717993f49954bad19d2d138d8e48a8dd59c834dc12fc4ddbe834558e21c158b36cd826b209157c2e5225b3b8a84b77eeb34276fad0cd148ce17594d313fb9d4ae89e1c75596daa95a8e5c41e54ad16dc75293febbe9c4e0f1a25e4237f444d0fd9359a5b42e69ecd57777b451ec3da5dc2253d1eec85d93893b1dd123ee93d1ac144445605b926590917d75a4269dc8f874c84c91cb2fd4f9efb78b6a83b7df65ded84e766b1823236ed0d08b8ff1b2f66beeaee4d818eb85ec22308c9a450120dd57232f92001108bb1e5aed2e651a78972fb38a191dc446594759fdf483c891eebf7d3d93fbd187367a635f038919206afbcd4bbbb761abbd82fab72cf84c32d0366c246fded7648e69a91db884a4a964a9197224095c9e65de5610154e1cc607892913f4dccbd6f78984159274ea2ce3db6f9fbb9b1a9438315bdd564a277665ee6ac6af58abb5d58a2e4fcf89fb3e3209fda49eb83543ebe2ef92fbc40ca618db7d2fc8cd3a02577b218745cbbd5a108531dbfaeea1bc8eb872a24eea67efdd9fc0b8e36998db725cd36e57f626c707f75fa48fddca469e204400d00579e5c0ee505ddf61ebfd43baddac119810b30a50e54efcb991d35d5e58936252cbcb3d9a515e2cb711b5c73c9982c97e3f06407fa0e545dbc09025cfddf170afe4da2208263a0bcf106358e1c0afc7d85aeeda31b40c8890f4f7f96d09fe747724c8b04a159da430c67adab0ce6924feadeb181af2be25a1fe0e34eb2d9a00541664e80d10059c196502a2b8495780f79b1a7c072a8856661202ab3eff8433ec7be7e1820708d90af0f671553778d750c5c00e31afa4ac4735427a9dcab28dbc2bcbb9f80cfa10184b965720d493a352d9e981330c3c2195220cdd848c41ea26ca5aead55183cf57df1e678811ea4b44abd935345af4028abea432f2112b0df7f23a98410c1ba7c6344ef6954d1003021cf95a063b411507a8b30514b486dd3cadef2087d056c2446aaea08dc111ab0d404525c5f76061f75745ee19d86373517a0d5032b7e2e5f8a0cc70969f45623a5e958813295da2c4cb971fe2391d70584429e32998da515804711c35271a3a6f885d2146b16bc77dfac89410c34046b550b3aec83a8b200a22754c44849e152c05d0a7a5b0a77d6ee1b29043e2703c626b7425b1f247a97ada5af8c1d1db4fbe43bd4d9785621d81789f5c402ef9bbad25015e47f16ba650d3f2db405d386c0b0f2b253c557ed556369e2e0b4a1e923aae0dbd4d3c125908a022a3739b0b0a54102459adb881b0120a9ad18a907981b4d9eb4d0c633cd13f11d2d538509f0016dabb6ab72032fac999a8dbbb62c25efb9ed4dbf1c11077100609df520dd0df401c3a7775cb2f9c463d5045844f392e76cc78bf3444f21a2a7e9d943d85c08c38ed8389b20674d33ef4d9353cb62baec61f56d9781475e2004c5092d0686cd18b75b35f141d7e9cb3c09819484ffc5ab9c30ccecd3d7703ee7e7b69eaf46acd518436428f85808c083d06b108cce07b2d7cb0268c2356300cf5e4c2b81a2533adb1c8b25ea3454180f636ac66459ce5e217c7c3415358875b693868e06979796310c2a6bfa1282a23197bd33e112143c62600393921ca87d372236ce277a098cbe69b0a24a0d183a9071b005f9b8ec3381df078e3f5fd903822045fd8591aee247313bb7d8433203ea2088b7fa9cbcf92d333b859f22c4c113ce150875b49339d4a0478f8b031918ffb3cd21f2f5f6e76558b1fea211161aeb990e169fedcd78309a4929265a745fb5d0f63484f22f2b61e3c2f9c3788f054aadcb562ee105997053cf3c32774bbabaa23b05233b4ba034e0a06d6103610c09ba40333300333300333006c1851236436421af92656262925cd07205a887f10da9f0328a594a49449a658e0c51375c3b66f3f09fd13d60f370fcffa722b6f65f7b996cde0bec2d3e858a34bd7383b61b3c2b3d29bfa2f75a991ebcd4605ed51d4b0583655e1c1c696f8fde2844c21478527b996eb9052e9a5c6dea6f03ceab4567b52fe68ad34831c52785a7636734e29e5721147e16909a1f59fd85b131f145626d24d56bd8b8cb8906253c930b5774acee5723ce1692d17db76ba4f137bb55838481b97377238e1516ed72da2e6d452ea6ec2839ccae90913c3e45d263cee31662a17623fe39696f0bccfdef789a174ca39a479aae39a8eab80040889192442ce20417117582c287e9245c8a184a7a5f5fd3ef15fd73e6a3a1933dce3137224e161f4ef13f92a62f3471d851c487874a97b7a959e62cfb544e3518a08d9428e233cbb4db954e546ad2bb5856dc8618427296ad6d5559c54ff4b280c398af0bc5798146a48ad7dbe0cb38892361a342c1624841c447898f2c7ecdcaf7bb6950ad9009263084f726aad352aa34c0bb99542228484ad14120dd2c6c5e510c293cdd3db8412259756fa4ec63b9c8c0688ba2147101ef5c6fa2d3267e79fb8c8a69379d450c8861c40789ed16643ac4b19192e175814be61b130c20b2a7c23a91f3c0b995ace8ff43b75224d2763c645d3c994280769e3d2f1c1e34f5b99e27a69d37aefc1c32bb157f77b3a63534522a40c1214cd2605160b8a66e3100f1e4755ac791f7bbf506b67f2252ab058105e90a362d8c1a3ac6a172ebbe495f86c582c164b918ec5b2105e708b74f282d00c3a789ee1bfd67615aa5ceedd41dab8e430429127655acfa94f0ad1629b9726115206c963b1b477efd3b0582c970bc2206d5c7230218e072542e9113bf75c32b60669e3c2e0785e3685fabdb758cb4cf7c6f376ada7b8bdb79cdb5069cac35cfd7b8c7bad7b8598d13bccb117cba77c1915b3a874cde03ca9b97e67c4b6bc65aaa5360fd2a73cf3db426f0fb373f0b43b62a6b9d0f17299308b707c266d1ed336fe6a6c3a6a20eea6c3498df2246c0e33adc2f7a5d62f209a67a9fcb68a59a3cdbb8d264f9079b651aac58c217bedfcf6397918e1ba237edff4e59ecbbc4281c9a3fa39528a13bba788e1a5cb70e3c9c7cbf96aaafc54dbcebcc925570a70f020ea5deeddb3f2366cc7943ca9bd4a9efcab33a17d9845c54d87837998caf59e112d5bac9e63f6c229496c224f6e52aea54dee1e72f8308bea327ff21814df105998b82c78cfb3e5e7daa22fb4f8afc3f9a7e932fbffc375d5e998c5bcbc094a4ae7422485bd5bf9b8a7fd3d4bf6e4b617bba3244b7b986a8dbdec6daf5b4af6b8d5aff9cdade5ebea308b1c8d53b8361d8efa83c8bf91437dcb35626a8d21cfaac4945ecb7e8cdf338ac1e5c9f638d17a883da7ebd90d1ef7949bafffa592b36d3678d861bb7db6fabdb4ccadcec94b3578544b9a506a8c299713c32c9af886c877322517e728899bef34d380ff9d7b2f23d4fd308b9c9872e99c3c56411b4c7936670f53a1565798454d275372519a7279cec65114ba60068aff9b534bf6fc18c32caecd6732660891c1f3dc3e4ff8afadb2b4f04d505284a0183cdc2ad173e6db56f5c52c3a932f794b0d44ee9cbc3402361e85da6e6acdf535d489984513bf28d4d56b3c2e11e2f48c5fb1c5ccc8708e066b90362e44843cf85842ff8d9726bee784fa1b4d4b359ef6ecd0f3f6d9d8eb1819bd82b47191411a9d0c355dae9825438fa982b47119028387d125274be488a9e6ab4580c683d0a33676beba29f78959e430bee0d9947eb94e8694d2a58c597497842bc883127162d4e9bb616b8c595c62b8e069baef8c52b94e45a767305a6a75b542ad50d55add8af0614395d2434c9b580b9ee45d6c3d728aa5eb4c28272589b1e041dffcd119bed414559af1bcd650d297ff5cb2a74d99b18247fd77d26df99ebbb32ce226289c12cdcb98d14a328e86c59236481b9757c693885d2295ef6db67c4c2453e24623153c4fa1b57821edffe65509359f87fd6b5d5dcbad54be1066d1955c1ea548674984944152244386c55224e342340569e3f2a4e071bdcf755b68d5b1af0d0079f47fe5b35efad0b3f44ca806287850d95ad46d8ed0b51587338348c6d3b0582c160e8ae6821ba48d8b23e3590ef15abf58a2a598106671f31d3380582cee4b5034cd62e16cbe83e2ce2d96cd774a5490064922dc74507224e104cf5a98fbae39b366c41c66f15b46d3df322fc8a8409983a219c304cf62ff924b2c3986a89a63163b1b0df30c9460f9422b973576db8a1bb280042853532e726db9ce57cc62c2334690caa5629e1873acb5cdc41688e0f55a65e8f5f152c46c4c638cc50d7d63eda5549e4e23a4fdbd7cbad05dbfaae59c460df697cddf6cd3bdd794a154639fe5668faa973eb7d98b5934413929b9385e6dbf90ab7efafcb15798b9c67a926beb966aa9d89c5dc27016556553c7bf5c35e7c54a73a2d9a0600a49cfbf6bcc315bfcbd9e5bcc228a66e310513e9e6f9dbaa69f74b3fd1b174d27213e8b1c257a8f3dabc570318b9fd198b44b2be978879388e869695573aa933a62ac1fb378a2d93c65b1b47f8344c81924279a8d0a2c1614582c1da48d8b0e42f06c234acb6da74af8d06316190516fe94d8aa2fb51825e5306bb198582c696d3a283900c166a255dddc45dcc5cd899693374c4c2ccf36969fdc89a954f92ae9a08493b2d13c2229ec536082725292eb2425933a272f0e319ec7c7ecb552865ca2aa9af181273da532644dfc9c96318b9784a8d8fe8d1778e079e74a35bbf6d0eb4b0ab3b8f94ca6e492a89d9397b4034f6bb98d48a93ba5fb1666b1b3e11384f1a863e96c175bdd7e1bc22c5e9639f07cf3941abdf48bdfcb875964dc0d3c9b5c2faeb63c214dd4308b706836443035f0f827756d97af6cfad8c32c6e3a1c924795ffbdc512424abd1766b173f27a8d0c3c0df173c5104a65c9fd63165dc62f1a87b933c0c083b81e3ad59c1bae6b8559c47052502e1bcdbb28192440488490083983a43d1b70781a8dbb82b47139e302cf32668dcba9f932fc8459dc38a65dd0774a3631b0583a27cf62f98da6713c06242853483a292717b482b47189c1c8e3dfcd314b8e1137ad87592411520609a790a8200d12122167905c32251714cdc66d6e3a28e9379aa682b4712181052e9c94cde512810a50800313e04820021170a3393331d1780002117800041c30810660180c480c2c60e36fd224a080045400013f307000034ca0004a2940800a0c40009c381200c4b48eb30b077c24183d78840100bc6460075e2e1ad091a342802c08a00b56c8f1279e018000bac0888a8f015406d1082e905121c21084f0031ff480073bd0419138e07823a5c3d9e4004593a9542a954aa552a95430442a954aa552a9547e3c0014951f0fe0450e5c0ca032884590818c4a2956600b1f3f2a954a4501191b10a0025d4042a552a940e0020a40392a908b4aa5d246e50729d8a0075278a0e29b4e1c4fca1ace8d4203a22843a5220a16542a71b80bc4709c121558c8e8688274349a343a6470cce068548006474819a02043a552e1949c84208eca0f4fc082f3291c4e490830ed3b231d471911c126e5bd1b714b60c2134cc831821c228044a5a2e311954ac58dca8f4e50a20282156836af030dc75da5d22a974e542a954c891a9c280227c488c35df09c94911213cda69319020219bc200642462c6ff29b87e34f46389d120f74321d8ee6c4032930838c110ba784f3992732f2342318e83c070323df29312961259c8ca6959c68329af626193fd97c672453124611938d5b9e48060e4b07c40863648c918c46a386462304a504c37981094a4a0ac6f8374ace08d2b10cc9943ceb3c67c4d7257a808912542a9521434c38234f64e31820dfe210e29b14bfc486e0f21d4de64712a850f9918435547e24610f030800031c222a3fdc252a3f9c282a3f5c2e2a3f5e47e5c72fa0f2e33950f9f12388000510108a0c547e84628cca8f5008a9fc0885577e84c207951fa1b842e54728ca50f9110a3b28e0010830c04512951f1752547e5c6e51f9312400951f432e50f93104557e0c792a3f86b051f9314453f931a4073ec0a8542a089840a5a2000820a0320103300002954ae5470184a8a1f243c81e2a3f8468a2f243882d2a3fd64040e5c71a24951f6b9ca0f2638d19547eacd12a3fd6e8547eaca184ca8f35cc50f9b1c61e2a3fd67844e5c71a9da8fc584316951f6cf4a8fc604302951f6c78a0f2830d20951f6ca851f9c146abfc6003c50005a83480010b50400210f0e300954a85000aa844008512951f28a0a8fc407945e5470e74547ee4c002951f39e84ac7dfc867346950a200ff4646d3505086806146a552c9547e4c620297cda3e4c81c58c229e93887a3d9343f1911c19038fc84646404231d88c34f48429083304c4abe8d846024074376dc40120f676341396971f8c949a59203159140038ae60039a8fc8884062a95cd73d64005245066f0085af82376f0269a348ae08855703468f87044ab542a427230a01190c8817284c07d0e4644f03a28e1fc668453f218201d8e060d8d4b5163448c116c342a3031712040c6184300638ce12e971214bfa0703828251d44b48108006830700c29711431fedf4887e370605a8918299de64346c83804222a954ae51060b08c1ce2c4474a20003146c470669420c888182b18c19f94743a993fd1b8608c3184c0a1c914421085904321da2884013241884410a20821523088570c4213158b0b462c433acfb96cdec4651c3392d10c1919c9948c0c7937bc33c61843469e268c113ce9c0b3219d5723f38221234f13c6c8902143861461238e291911e3398e4179666c1ee5479c900ea83122061b61b84c8a66e3cc58c113d9f8ffe69d68364fd3e15c0621867b418c4210504029d2712e53326271194dfb0e6753220819542a1641b0fb40c0a2039ace092a3f0281064b0702014720c2a8542a160e476332d249d110c99488d149611c0d060e4060a262e940061070e08c701c0e32008162e980a6e3fe0dcd4918236a00028dbc3142c61f505149717f80c3c81f805001c16f508a6cbca495bccf3c0afe70824ac5c4377f7840a562f1032a42e0873b542a154de77ff32e707ce602c767c618434887f3ae0faae80317fa80833e2c800f81e0831b7c00c20705f061c71ee4b0071aec61c70f3db4410f26950c8c8c7060f39c14e76e94988c7438292c18e9c0a76c3a618c780a91910e3cc7c45f1862701c339279cec547c818190304169492f69b31867438ef868c80c062b1b4ce8f88c17922bef922192fc2507e83f299144d1131dc18d10819b16c9e89d181219f5232248c118e184e0cf719e75cde84f965c4b229e9643e0fbfc80320f2b0833c84a052a99451f9810754e0811015cb908e46b31932c229e9c0906f194d9030467e23c66f8a98a0683628283ed2812143c21829c994647cf31d132fc183c383e2810394b064c0e4a483b1a0611919c3d2c9381c23299a22237f52d2d140b74563031a8c3ce60e44b803de810376a044c552c44d36ff8686fd89ab310282b649d1703a28dfe278934ef3381e3b80c10e9d8a45c80b5e9046c681588ab03a7c1d52508702d8810e173a88310751cce10973e8c11c3473c8801c7c210733c8c1e5b0e2108b38c061557ec46107954ac572c21941410a463499110d67448c4cc90808dce0f848118783336488cba498788793928231c61032e4a57181e333978c668c31322f18630c2143464646d8882b719ccd080846462c298c53c4e13071387ce332de2ebf49e1647ec808084646c648c39232a2c9988c703820b0bc1a23160e470c136f259d924d4b612944369e82111058369a21431e0e8dc9b3114e09072c9b7fa3e4db6ffe372a18c21932c48da63983b3c9bc0e38252799d78166f32effef7ff3e080094c070e44a8548a9870523425296c840c389c01071f960efc1b25260e0e954aa542c61b6a60718e67c878c305dc008a4ac5d28111f761fc1b252625239de790e18632b84946a3e18c6838269e21525282128c88318211c4a141c1d36836687c0bc61843c8a50d6b78954ae5a9fc68c3052a950a90ca0f3678820d8d60c313d890061b7e58369896c219e1f888181d18b2c6b331248c914e09a7884946d336df301d0d7b4f33e2fe33254ec4514a3045de0da7c1747ea32979c331cf3825272118594316d680590303d400083598a88101954a258dca8f340cc28d4aa52283ca8f3428000d84a8588ab011136f990ee73b6e82e98cc0f199211777e9709e0dd174346f8cc0f119cee63b9a37381a0da665de0def8c3c2392292142c44d9e260387c671c218f98e6f842084d03d918d0604bf3131f993140ec7478a98fc730c91144de64730444a309bef3c1f52c4dd779a677ee499a63322c648278ecf644a88fc88fb36c221e29cc8c8081968a4200819699431f2250852821114719377413a7e711c34704633e24c341d0e64346e84031c383e081a7e9c011295d76446c4283903122a9533a07186302a958a1970c131431b389c0e8ae6c23103aa5838eebfc5f1234386940116958ac5e4356e1382ca8f32e0a16229434919c2a8542c43868cfcab6131219229e17434190742064f90010e15cbe6392921d074465c08dc3fd30421431c4f06342a64f051b19864c6408a37d1a43106348c4153a9542c9fd1906129b2d104f9374a4c2e9a4e0936cf596304edd928417b3636cf4911032888644ad610030dc440803020a262e1b8cc9ba4bc227ef244fca464d338ef46c4c0b4148e18ee9c8f98b866c810313862bc890648187850b1707cc4e44dda88cb78184e50a954c0a00930d0a152b1781b62e16c9e93a2e994c02f9cdf94a0c4f1af86a603061f3fbe00884aa55224e35f0042a562f9820c2a962f542a950a195e8084060d958aff66c40b40f0c2099e66c8909122cc0b0fa814611d38ba008a215d00c208a764a4031d8e0665a31909c38374210c8ba63312022ea08253c2053c70010a154b87a341c1743441b82083cc9f64bc1531c9bc800b2343868c8c703820e4c7162ab1052c542c43863c66a30162e188d1e16850866c210e8e068d2d8451a964e0d090a1054c542a960eb81b1ec6c8e6396b68210d958abb92cb673a289a8bcb3c26062e4386061303f79d12f7261a0d7366945c38dfd1bc8192a2d96c1ec3718ce665ccc802a6888949cacbc20a02ef8266a84005271c87c362b9a02bec20c3f3debfabd4ef44c7f0b4e5864829a4bcddd2f7548be159e7cd3eb9fb6216d70b7684213d5dce9fab45c62c2204c3b3a8c98d2d7fb6945b0db3d82bd8f18507735ba9e3a6646d31dde185673db384ae0a2537655e337674e14144299f5bfe6dd1528d596416ece0c2d3103f395be23244df98455db985a79dadf7947bbdf75c6b977c37dc84a175c10e2d9c683417229bcbc5c78e2c3c6b395f8ba9e7b7a9b9d3a40becc082cb94c09149b9644a883c43c08e2bac951813bb6f98c5e798fc65a3b9a0f809e2a2c10e2b245694387b13d2c4da6915f6b345ccdf165becc971edcec9db5185c7d3fad65c2562ecd34d4c4a5a60b1582c3ba8f0b8436cd13163e8ad7b865964213ba6f024e3f4d814b16be35652789e36770eb9f2a7b36e51789462ffdb787923d66d611655723ba0f02cf42e39865e4bfcd74f7810a14a0915738d9759c22c2a347638e171b999dce97bf3e37c9845c5263cddcfbabdfdcc2dd708b3d82dd8c1842725e5ae587acd5bb79538970e4783b9bce6ae206d5c9e1d4b78ba755befef92bd42b9308b9937b9b47fa355b04309cf434ea6fcdbb25dec72e234eddde2e21d49783299fae5d0ab66e7b9ba82b471596307123cbdc34d4cb1d59845e614569b0e4a1a3b8ef0b8f5303d27a54bad46a6457cb3f175b2c3080f432e1f511bca5ecd591150e5224a2b3bb913935a0a99e5430e29e7ea533d063b88f02cf649d535f456b64d3e840755dd517394147b9aba43080f7b52f87c793397de724a851d4178b2b5a65cd66e9ff8215f1005c553476107109ed6eed053b375dafca2e93089903234422c16f68ba7793d2a64c7b2b1f3fae279bb50ad734d999977eac5b370b17babe9bef5c5e7052be6e2b2ae22a5acd4a2eda5ade5ba4fc9db7e178f3ee69e2984af57b6cdbde0fa810e5d3cbf28d552f4562184ed72f1b8b3ea7df55872dd65b87856396e54d44eb5cc8b6ff138a24f8c7079426eab74d8e2799b9af15bf9e88839eba8c5833e9b2695d989a81f2d1e970e7b25f57667f13c42b58a3127b76afbc9e249da7453cbd6b9fdaec5e2614a5d43283d7695cb122c1e640c3dd4cb6eed2aca573ceef9b3a65c3febdf86ae44c3c6054f74b8e2414c7487ddaf95f2228b45d34129b2d1df0c41472b9e6e853ce96bd7567ac959f1346337f72b6f2c398656f17043dd76a977d5ef34a9825332a3d50b132b44a959bde75243cb565aeda1b7a978187b8fb2ff315fdfb3a33151c3626122e840c5c3569d3dcfd54ab986788a479f3f94cc39cbf4082d533c28a55fbdd4429d086d29d6a242993a21528b0a21aafa4a8774b1e4524b7ea478b85da956cc7db365ea2c168bc562e90b22ae6f527cdfa063144f72d79f9efba172e5298a275b5ba9d829e796afc6503cae7365bac3d440a170252766a6c40a65269414f26ccdfdcbc554ad7de269b936d742d4d07ed2e789c7d5a574eecd5019d3d589a73546cd29cfc45225d7f8c289475f4bdbf8b5bb66cb6ab1582c7c41cc91051d9b789e79eb45fbf039792bcce21b252ea5a039b115264d3ca8ff79e36aaef9432b65e2e1c7adb89aa6c5bc254c3c9fab16b66f7c8927b532a688d66bcc9fcf122a5919d5e64abb9266dae40af5c3f4f5fe3df7ab12cf730fd36aefbd66a610774a3225175de359117701ca4e49a62493727956c44f124ffe4407259e65a488ea8eb1db6e3f89a77537b4bdbe3579910e493c8e50ad678ddcacfb19892711ba524831c524689c41d2283a20f1a83a42fa09133931e5110f53aed812e254f4bc9d231e964dbd19bb85904a891bf1a4f7eb32d1faf7c74e51b9a183114f736f21bb740a35c610130e742ce269951cb3766bbdf414dd44a361cb4487229ed6c9efad8ff799eabc6c3497cce61737cf417424e2e155cddc27d5fcdd3e443cd8ecbdf36ed98ca94c3a0ef1a4d7959a8c1cbee40cbd4fc1a3141112a48dcb1b3a0cf134f72b3d3ac5c648d52bc4c34a35cba65272fe2723c4b39a638abf3d39738da98e4128843669529a888baa514ab8ef8b5ba56bea6ac5f119344a4c50d4d8743852d0218807a172458cbe696bae3810cf5af9e8bd11f6fab305c4c39fd02747b76ab53eb4321a132016cbfee169ba88df2eefba226733d8a0c30f4fbf2f768d8ef163e8b40f0f52ed32ada51e71d37f4cc7d1b0582c453aae830f4f42f41c5a9754f62b6d2926bf4159d6b18727f54366cf2d5b6dd539a6e368284cc75154914e2a1d7a7814b5eda3e323c5da1ab388d20974e4e1517fcdb2db42b6ca9b42ce20b1582c160e1e9e5dfa9aedcfcbdeb7bfa0f8c9ae40c71d9eff47b8d05bbe2c5d7a98c5cd274c83d90ecfeafb4ca47ed3f36bc22c72fea464d3e14e6e3a9c3a3cdb9e961dbdc494107acc22a784916352d24921810e3a3ccaa85d6bcc3c6143eacd61b1c4c44ca56f0eb35864d3c93c9d8c37678313c54fd245871c9ec7729b2a3ad4dd8ff95264d3e124e888c3a3e829f296fb1a62f4940e383c9a56267dec55ed93536f781a7aa6963ded7fa67d373ccbf8597b8b9c72efb8b5e1698b085753a8b162cb6c78d8db5b295b68296f4d6b7850728bf6d95aced17553c3b338b1d4f97cdd21a64dc3c3c8317fef1f2d738d1066315372f98e63193ad0c02913e2a64e89732154da8cf5335aa4d8db869acff0205ea82b21269be171a8182d2a532ff5a3c52c12c994703629ed3799124522eee9a4b8600508f39d26a374704147199ec4967d932377dad292e1e186f251e3c3758f390ac2d28ee1e14e489b2f4428a17b2786a7ad84acd623c7bc4f3d1d614068a9b2426a9522d2a57097357dead3b3c71273e900c3b3d673c8358512538f13d3952bb058f682171fe8f8c2a318d75f728badf77dea85c76573f48a123f975c431d5d7854aeb64aa44e3dadfe6f1489903252503266e8e0c2f3b2e942f8d8fa5c7ca4630b8f4a764811ae6ce45e5f87169ec79efb5672bf94d36c5950a53825566c6e4eb85835317faef89af6badb8485545cd4aa53e24aeed56a755ce1f944f7eaf55aa9aa3dadf0f0636d657be6fcda4b69b1680669e392030b3aaaf0206628b5c61cc27e0f25151e852d3da166aa75523505848b4869f672ab6a4c7e8ea9e5dbccfd8d2e8567a1a78dc89d7af5a357c9093aa2f02c6e8caa216b87ef1e141e7e4e35756c4fbedf9ef0b46d478eacbbaa1c25273ca8ce087d6ae7f7c5b0083a9af0b867874a7d534b2a9733e161aea1735de831549caa6309cff7cbf6b56a73f325a78427b9c59ccf1f5dcae52d094fd3979826a49a3bbb77243c0bdbb2e6cc2f2547bc741ce169c5cd8b7d632ef7b50e233c0dbd42c8d2c2b689e8e928c2f32e7f596a6879abb6ae83080fb295ef8e6562fb54a46308bcb6176aa74e48294244a95ba3948ab1e6d821d62184a7794acfd63b6aecadc537d16c96a023084f36a46a39b4dcde25651d4078123926d589defbc5e30dd5f132860f5b255f3c2e7bf5bbd5f929d5b2170f63723fc6677dee7fbc78342d7c6dfedcd63ed676f1707b44c63c3176ac14ebe271d4d23346cf0b315a9e8be73d95e89f5bd718ff6bb878d2fa4d54eb8be9c2a66ef1707f4bb8986563eba1678be751b95b7d6aacbd875c8be7b7db7d727bfffa325a3cfeee657bf6fcb25da759a862eddda41a95ee264ce48d5ff26a9ceafdbb93c5c3aff9628b58a6e5daa75e24e488c5a39e0cd3a6424899ed2e583c0913bfe4a6df38b3b5c3d12477389a5c428e573c29df6ab7ef116772ec5cf1ac5de85b2be2a363d4563c4b977aea2533c6ba68b1e261fb9aa66e8efb9363b78a4719a93afc47f7941053c5938ded3f2955ce5ddb4fc5b328b196dea8bf6ebda1e269c95973d9383ffb7f4ff134a758726eea7d5a84cb144f23eba6859021870d65299ed5c8fbb5c51eebd4aa49f1b4850eb539b754b1371dc5a3163d3b6e3bc792d313c5c39c25b749572546b51d8a5d98d8ba0a574a8b766d5a8c35379bebe6763581e261a62ab1e61c3ea28698ea428e4f3c2c55aea432a13e65f6168bc5b23cf1a47f0bb56ac6e8982b979c1c9d78d826d4562b31b6afee6470e2414c48b1c75027f7d2f1261ec7f89b267baf6bbbaa898711ab6abcafafde63269ef7560857bb63d99fcfb93c91cd9f200c410e4c3c9f9c75a3be54d9323d6631b990e3120f42c64e6eeabf3da6c5d2790e422de4b0c4b36c3511aa5daf90b9acc4a3cd15b9dfb72e1b37c32c769e484ad9c818a48d8b0d7250e2695d8d1fd1354c4ff74de271dfa7091bf77b28574ae259cc952f4abeb852368cc493104346cd88f96fa987c483fa3d979c3e4a9932db239ea55a67cbf5d2f6af438e48446a61f7ca4d6b2d225ea8d8ef5e6aded68cd436e2d16fa92df62bb1a2f78c59fcdf742e888f5244081c9acd468302859c4ae460c4a38d8a39baff4ccb61bb6192c27af382e77f061b2440485a400284c47d068e17582c9b7763e327ef34412c168b655117da22c7221e6f8bb097624daddf291a6990a0800408091924689c41a2342587221ec5d4e28716ebd4347d592c168b2a26e448c4e3aba9b2f97d3d1337443cecb1957bc57f2c9dda433caabbad4445e7f2157a20e430c4a3da19b6c6ad21e63ab1104f4b8eb95efc50a1b37b423cacd83bdee5540d1b77108a9097e245e66d55458acccc3521dc77d95c9d209ec6c4c4489d9d377a0dc483bf587ad54eb96c6a17205022dd5e692122e45c4bd999b362ced5ea37666f418e3f3cadd03dd550f7a5d3d67e781a72d66d9b5b0fdf3db658f6822b0839faf0b45ffcbea9e6eb963132798b0539f8f0a0fb979ad8636bd57a845924a231492bc8b187e7717aca3d6f9596d36d9845229a33941e16116b7342a4166fe26d754d9f1be2c5f4167286597c22443467a06882582c4434262bdd20471e9e95f0b9f77015afe5c7962fa8841c78785afb4ad7093d5bcab6592c7bc12239eef0284a88f8f13f593ba69845939493148444c8192426292eb0582c168e894909db3c1a168b25481b974d0e3b3ccbdc29664d2d6bf958611655062b481b9718e4a8c3b316c245ae9da922baa6c3e3d4d3b32f46c8d55ac86219438e393c2f3db13355576daf590e0f6bafb8107af8fcb5a7e2f0a8a5afbdeed3e14b6ef1050e0fe36aee9bde37564f96428e373cab5f7ff3450ca1a5afd70669e382c9e1862739c49ada9b9b722d315f723821471b1ef54d462d97ba66a78869363ccdece5e2e48c33ade498454e661a39d6f0a445ceb2d3f3a3a60a61163951530d889a74a956aa1152a85bd7366ecb7ae16e634d89c562e99586a751739f5cae64e76b95361a9ee6d897337508b5a7c51c139493927586e76dbfe7eba5cbf58acf0ccf4aef336d27e798d53e66859c41c2595c29c85186e71fa53aa498b36126478627f73dade2f2d614a91cc3832b7f19276bf76ae8c5f0a8e44ea99d37e37a4a61d885bc189172aaa4566e2e975659b2d6cbdc27189eb6b2292b73b510e24a168b05e1051ba7e444a97ee1414effd4a3a26ab6655e78da73b6edaa613763435d785c2d569d1c2a6b9ddd308b978de6d279220a79cbc8c1854d9d962a73eb5ab98c904a8f99a76399aa1dda6523c7161eb758d3c51aa553fd98b90a39b4f07ceb7f7f5284afee5d5b2147161eb71aabf3b77376ea6316352fc329e268582c16cba31411c217e426e4c042e84ca9d3d5fde6a90a3c76f128e58f5252f95055aba78b076122c7f2a58572a10ad55a69313523b492999b7bda8e5571e64208170f7afd90f57aff6fa986706880f01078dce2d997fabd7342d5efe9dae2d9ddf6da43469816f3558ba72da66a865422f3dee7418b0753ddf319739794d2e5318be7b1be6dd4c8d2b2a61c0f593cdbebe92326675b6fc723168f2feca4b86a3d6fabe4018b545d8b2a9b93d2b4d2eabe4ff4889ad9237642af787a29a75c9b22c672257245372b548b73f1eadc5c8bd12946c77635f7d2623c5af16ca786da6891ea5a81072b1ee4eecf75fa76ab332166f182e8293978d02a9ec4b8b56cf6e5b815c3d4aa785e6e720fb1e5caacdf318b9a46a7e2e9ec5fc76c315fe9df5b2c3c50f1bc666da55aac54f5eddb3c168b6fde626925253c4ef134ea4c6ee6d25fc365c9144f5a9a6899397efc187b3de0518a0725e372a652ce5cb536718b8507299e6f6e29e7ea6bfc8ca876c063148ff3a418c25cad5abacabda0281ed4889d7ad7af1b7bcfa17896f1f35ee9d6e93e5b503cf8f8b1438e2544b7483ff174a694145b86ab0d3c3cf1bcc71ebb152a54c9ad77e2c1b4afae77b54d4e51e2c1890713e26ece256f4b9f30063c36f1f84a4b11b55fa7dbd4f3d0c4939639f58d7af73dc6c42313cf635d7fb98a90436c2dcce2674ad889a6252a9a384ac4c4c3afdf623b96d25ba79e11785ce2716f17365ea4db506bf73c2cf1b443a8e1eb72f95c696b3c2af1b8878d8cb1e66caf5c11e14109ec95d92ba1a4cd682942c4f6127aba163196bbeb4c5275c06312cffa53ce773dc6988b13c76209d2c6258587245842fd966627b422818e4fed6264984f3fc303129f9a0d69dac5ebb951783c6225855ab55a5d56a8d3a2f4cf4dd80c6923d449b90ee782c25985031e8e78766db27ae6d07bfe5e6bc4b3deb1b5ace8e9a744ca880759424ca9b67019e95bc4f3aa2935031e8a785aeb7ffebe21a750639f8847a1eff4dc98bbddd942c493fcaa161bf3a58b8b781ca211ad42ada93bd3aaae566d9d2d36a69f947a66010f433cff6cdf6aadbc1eb95788c7a94fedaad53ee77c423c4e7d11df2a849bf207f128d592bd6fc83d413ca8ff772557ad9b5bf602f1f026c48aa92fe474b1078887bd254effcb5aa3f7fbc3b3e8bdc7dfd43679e2e787c715b31336375749edebc3f3a9df5eafd2c78787ed528957520aa587faf6f0b4c7d86a21a226e47c7a78521d3387cf974387e8e5e1416f9b42dea98e21f778781472a68ddf31650bfd1d9ed4905abf5cc36585de0ecf6aca3f7926e5bcb5abc3e3d0629512315bffece8f02cd7e58cb871d37b9bc3e3ef6d4b8bbc4d9d6372783c9dbd715b0e1d39fb383cdf09217a2939c756620f872721b75473a5a61869ff1b1ea51c21b75eb2e4777e373ce8b9e37d6fb9840ef1b7e161c54fffb77d37ed3e1b1e6574db5cf17b6dacbf86a793a76aa4ce5f53b45e0dcfb787fcb9964c6d42f5697856a57d4c793623f5f468781ceb64f950b262e9f3cff0246f756915a695d0c237c393eb9f33a9871c33845f86e7a13a6aecdad367464f8607f96be48d8f16ea453f86a7e52275d48b12be7d4e0ccfb265fd0b256ad3e65c189ec77671add4f693b27360785e1d6aaedca56fb8ce7de149ae8cff6897dba698f3c283965fd57aea77a5d6ae0bcf42e95e5952682154765c7896b247096963e93564b785c7955d625b776a15add3c2835437f61e6b958507b9c27e4aa544959bb0f0b8fe87bbd0722efbe5151ea79e29ea2a54956d85276d7ace135bcb94535885e733b533950c5dd1234785a76162eb1e395fd6700a0fe27ceeadb28652424f0acf7baf53bebfd6ea8bc2835a6ae7545b941c150a0fb6569ece9469fbfa273c89adb3f499b031974e78122e267ec49463c6263ccd36296748bd3b5133e151ab5f3e4edd4deabc04d59fd0be4c6f7928e141cdd5ab925d62ea9547121e76cd8c34335b26a68d07129e85cc576a422dad2b6d3c8ef0bcb769b92b56e4dea5c6c3084f72a47075ab65aa2f1b8f223cabf5fee76aa24dcdc683088f72f689cf353647958dc7101ed4d8b26deba1d53eb3f110c2f3ea5f36aafef412cac623088fb6f51452adaa907b6c3c80f02046989e9a7bbd536cbf781e21c7b6efd43e7ea8f9e25185ec09914bbb4ea1d68b07bdf69aabfaa9fe3d5e3ceea96a2f11cb56fade2e1e4d691d5375cd5e7ad3c583cd9a6b4a936a0d1bcbc5c35cf3c7a8db6c31c6182e9eb5d66736b26589dfec164f33e75836f49aa868992d1e97587d222bd4729fb25a3ceea9aa4be83dfb6765b4785e5b6da1ee736c5b2a9bc5f3543fc2c5ed12715b4c16cfe6334f8f5a51fd2e168ba7a122a33ab6905b1783c5e3984a0abf5575a652ec150fb77fd5cdd8ea162173c5e30bb3b962da1c3984582b9ee6efa1fe5ebf389363c593729fea6dad165ba9ade261feb852b263aa78d2f3ebc7941ca6873c154fb376a789319654eb46c5a3361f526cf5da73ea533cc9bf92a5edf41a7b36c5c3d2fab7b90fb1a9d3523cce75fb7ab7a4562525c58390bd96282df752a77c144f2a74ddd7ca25c652ba281ecea548a14a5fab283d148fabc51a6b6de13f7fe8a0785e4a8b352974e69cd03ff16a294a98989e785e2b73e5eeadf70821efc4939c123d7546a694e2c4f36d9fb6d5a8d9a37c9b7818ad96dab8d9bbffd7c483f6d772d41ceb679689c7b1d6a5187da3a48c8987572d4cd5ab5da25562cb1a73dd96789e7542fe0aa94675ee4a3cab89cfd1abc64f3937251ef69a31f4cf97a943db93789869a2b594d332fbd592783a3d79f2ccd59178583aa418a57b4bd65243e271ea354aec5ad2e62ffb11cfbaf44cfbc96ad7a276c483b0714a8556d5ebf61af1a0a6fd92f396facc9e110fab72d8deb3e77a755bc483d662c76a551f5f9b221e95dcb54a662f35364bc4a3d4a2b75acea865628878964b8a9cdb4e4cb1e4433cbe9a724e08db7aed6a88e7255a6f4dbf96556b219eb4c97db5f7b9aeac84789abf5b8e14615ba7d2209ea4da78b39732e42f05f1b055af6995bd54e9c8817856b5969ebdb552fa8618108fda86d6ddf622b746fc87a711f76af8b0b12146ec874731a4546ab598634c5f1f9eb5ee14b2b5dae3a58f0f8fe64aacdfd03df27c7b78d6ab54fadf5ed2c3c39954c2974aa154fe9b87e7e9426bbf3dc790ef2f1e1e953e5f2ef51c9333db3b3c0e972277ebb6c393ebe5abcae43251711d1ef6d6dc4b8d55bbd7960e8f2ebab4ba5142ede91c1ef7af9e5fdb85da4a95c3b3fd8b3dd5caad6c6dc5e1492a79d136b5aa792a383cfb5efe3eb6b51c6ae90d8fa2ce9618a22f9634ddf020f5ce254ca85e6e1b9eb4db4bddadf42c29b46c781ac24c6b5b4aeaafd6f0a0c6d486d9ef7ee5abe149ddfc51b94255b52e0d8fa7edd71e5bdf9861a3e1492c9d1bdb529dd89fe1494f35d62ff59bb633c3a35a21e3e6f9d6d2323cbe5ac2d5dc37ab64323cec14b7b17ec494a21dc3d3aa2564a9f9bf9c53313ce91f3552d5ef21f72b0ccf666b9dbbfffe0a15181e6c6e295da510bb4aa85f7896376d6f31d5c6cabdf0fcb6a4b4173e3ab5af0b8fabf3c6b414fac71e179ef6a82c3521c44edd169ec5bcf5d7cb8730f1b5f0307f6a37a9e4877eb12c3c8d1453b66fb1b73039161ec4524286eb6573e4f80a4fd297ad7bf537d469adf0204b9a1eb79498fe5a85676572abddcc99325e54785adad53ab5c2d5faa7f020d73439a574df5b4949e159cf9baf72df7a9b4a5178dca2862f15c2c6ec25149e7eb5101d6bc79a32ae273c9f98520bad7267ee9cf02096be5437a49cb3fe263c98d8de3b614adadf98f02c750af1c34eae74b1253c4d697ee7b273ca9b2be169c9b235a3975eeaea243c0f5f6b8829a16dcb90f0e853ecd762cb47789eaacb77ed8cf0f877274746dde97a8bf0a4958ff5dbd474b54684e759dbd4fe995b995287f0fcf22ae5babdb2d22584e7f55b6efaa969fb1784875d5dad5a4fff1e0040783aed53ca2155ea174f534c0f2dccd5752b295f3ce9696b33cf749e99542f1e778bf29593f92245c58ba72984cd954aa476f1a442b8f225a245ee3d5d3ccd315b8d97625689b95c3ce8daaa547eab29b1868bc7b567afe4ee8935c56ef1242fbb7c6dbf1622668b67d53d57acd8dd3ed6b57852426a39f71e3a54cdb47818f374a408355d983b8b27f5d9e375aeb2789ef37f88abfabce58ac59356e2a36b889fd729583cf8d9cc98a56da7aad22b1ea64dd5f2c67c6aa94cae7896e26aa3e594a1b730b5e2f195edec1cb3aa7a9458f1246689591ba2b48a873dd56972de104284922a9ec5daa5a35cebb1f9a5e24969255beb2d43acdea3e249d9503b634eac9a7f9ee26189f3f52fcba5507e9ae279ee52275eec59299ed7509d529df075a54b523cc8183b63cdef9c3fcf513cebcf194bdaf43bd35314cf53e69ee275e6525b67289e844b5d6b44ec1a3595a0781c5b7af4da3dc7dcaafcc4c36fe14af48e7b69c2f4c4a30b3d3d3b87b8b57bd88947917be928a52772e821271e746b75f2ee6fe241bab9dd99aca1774e134f7a2e3da78bd4dba2cbc4a3b810a985982594d061e251f4ce4df81673a6da251ed74a9faaf58d899c59e251757c65e8d0952f568987bd3dc667f9d85c3b251ecd869863ba2c575b9fc4b39a266a8a3d976eb125f1fc7b4d083f5d27728dc4e31eb547eadb397a869078145343e4ffae35a6101ff1f42a366b4d2de7de2174c4a3c892af6ab9a8ad43d88827b1223ee56ee8f98f114f3fe696ab76d7d66a6f114f5bb84f1fddd3f67d8a78baf526a3950fb1f72e110fe3b676a6095d53c510f1643f53bdbc3d54d8fa10cf3e5ce9f5da4cdcbc0df1a8aea4d8baf7bb34b9104f4a89f591a3af5f5e423c2bf99973ebfd53a43a88a7b397332572cc5f258807b31139e2e4fa29a9403cd832515bce00f134c597aa8fad145be90f8f6aaa8a767911bfa51f9e6de52eff11f6e171c85e763285d00e3e3ceb7ef96bf78f39b2b23d3cbba8b7997bbed4165a7a78145b0af5afd58a5d3d96383bf2f020d616f7eb3aee7c98d4043bf0f0a4a6d631e5ea57a6507a4880582c41dab8c0b1e30e8f365acb56152d26e5b7c30e4f42a5ec2fdf630aa9a21d75785cb65dead8ae4aee2deea0c3e3b429969ad1c34ecf35663165c9a6a3e6f0e84bee495f9717b352cce2cae1718e90eac65fca89c3936d5ff5bfeae51a51a381c3f30dbdc7c8135313b7c52ca27cc393a9f16ac9566b4dd92b373cb99a517b66edf8a56dc3a3f025e5abddb6f7276316d9f0f862ae3aa64e39971a318bbc8607e9da965ca6d765b512b398a886e7e1ebe6f0b5c4daf24ac39369d743454fd9eac50f83864de9353b2aabd2e46e19ec3803428596b5991ba132eeba647fcb2fb9ed30c3939232578c5d362411528609ca89194550c0e1381a4e03c4825ed8518667391b35b3a5fa1c5d4a5e394ae1430d8f2fd7c9d96a77858bcb471a9e6dab2542ce94b146c768789e21a6ea72d36bd7ee4d838f333cbbd8a2979a356deac76678521f76af669c96be7c8465f051866725457467fc50a2538d0c4f27ff6c0c21a49a0d1f63787c1b63b4104b546b0b3ec4f0b0b67c31a4bfb019135a6178d07929c6d0ab6f2fb9318b4ae3f0018647a94ff4ec99537a448559ec343c97e0e30b4f7bcfe17309797bae35c62c7ae179f7f03df55273ce9393163ebaf0602ed386eddceb352dcc22a6107c70e1694edfd3aa76dd781d61168b3420164b91963a80e0630b4f2be4f0bf97b5a136612e6386c5f226ac844826e5f5c28716944aab50424bb37391172122d68958c2d6e89a8d59e4382613197c64e1e94fe9aedeaacf976298c54df7c007169e546ad34b48a56b659f7c5ce151fe5e117b4fb1f58bdf87151e6fe813e2450a11ba4e1f5578767da753081fd9638b7c50e159ffa81f212ec22e1c946af898c2b33cdbaa95923e7d89eb430a0f3b72c8ba6daa377dee230a8f7a36859e429c7c40e14988107d76ae8768f0f18427d3af6e6fb9d4d3350d830f273cff8b9ff2630b1b7f63e205312de1a3090fe26b459918f2bfb4021220246590002151010990140069820f263ccfb555762c29d6b492f958c2b392bfc76d9b5b253fa5820f253c2db5b5dc3afb7476de1df848c293fc2cfd3bb147c2d39c42cb2dce57fcd29deac1c7111ee6f5a6e82d3e55edf99f5144077e4627cef830c28390fbd7eed7b6eef45e84675baacab7de62b598b50f223cc9fcb575c774dba6c28b8f213cdbcaeabddf29a5d69d0f213ceb8958ffb267cb927e109ef694d9356deb713f4c692fe103084f234dcb29bf472c91fd2f9e6fcef9fe5a25b6499b2f1ed5ea18ffeddae58bb15e3c2fa946ccfee77211635e3c8a9dbb7ebabcd3d9ea2e9e579ffcddd467438f922e1ec51a3fc3f79427c396b978bae5a7f60ad5ad57bab8789a5a4bf79fa397d2ebdc0118b77818b7e6a89f37450e3d5b3c0edb734eb1d3556eead5e279b492ea62acab55a94b41a1c5b3701f7bafd915b9b43d8b8713d3d65c7ab4fe3922899032742d593c4a6126b4faadb6ed8a62f174e663cfa96a2d95f65bac00062c1ec73221dbb5ec81f18a677552be6efdb3a5aab176c5c374bd4f0ad97b5fafdd8ae73995da89ba57339763c5b39cd7133db3cbb62ec158c5f37a31eab5fc7923630a862a9e97daf3b3b5579af2b1543cac9ab725b35ee7cb1b150f4284ecb371ee7ae61618a778d0e3941662b5af102a533cd89cf8f942c4979a5d8a47eddbd4f9dd4a8ac71da3e7caad665bff2c88eed900c6289e56ef54dd77bf64dd268a07bd9f576ac87ca1630223144f53c48cd071c3c48f39289ec616977a56af4d00c6279ee675cde9623b6b0ab1279e4cd6e74c75a953cf9d7810c365b5ec5a22555d4e3cf9b6f56e6b4ef5504b3036f1ac4c0ce1f2c7ad8927b9b656f337b63a13cfb6b470256c9b6ab83280818947dd73d48e964a889533302ef138662c3b1373476cd5236cb4c4932ebdf79cf285523715b37871994000a3124f27f2a55c6b7fe942093026f1bc6ef7e32e7334283c004312da09e5ee66b7528b1b51bdd6506a49553dbe8da67321c255002312cf73de145ade8f5a2dd5308b0d8947b94e67ea91634c46de05301ef130f25b4c31c4f6d76db516c070c4f3d0376d466ecdf4fa8d7856cb5ffdc89fabb1645f0083114fb2cae56cd5d40bc058c4a3dcd6b963dfcee5ed6d14c050c4c33e31735cb418312b4ec483cdcc55ba57ef904220240f13c040c4b33ca5a6725dc8699579c7534022e40c300ef124a342dd84a8512d621806300cf1ac62db4f3bd3afa7c72800a310cfe2b5d67f5ae76ae9afef68de6028804188071fc3d5d48eb1d5d4de209ec796e3c467b64dad3720242b2011720689c5d21754413cfcd9fc542d6569a9361881e0ee445ee636b1ddabdc7450d40003106e1f7125948bd7e2a680f18787d972cbd5b1ef5e4c9f1f9ec4de95d94d2d6b2dbf0f0f7b6819917a7c3e3c892c71e2e6a7da9e6a7b781e7a6d8e9ba3b4899ae9e149bc4c2177bb2c0f8f2b63ae6f5f4a9cd98d87479121a2aee7ea9513dfe1718ffd6ae96eb2235f76781c2fbe3744e457d63a3c2ea9f7a7bfd2553a94747812ad5e0bbd544e1719cee1e994ed5a4b0b1df1cae1614da564f82fd77ae9e2f034e6fd94392ea42a190e4f3ef768f1a1f6e757a42c165780f186a7bde494de526addf0a843fbc8797b4aa9dd85d9363c0d971db6a7f8b1e1599798be85f96d0d0f37e6281d3af55cd933353cad3cf725a4beb9327a1a7a574acf396bcb37351a1edd5ff85ad5cad4d0fb0c4fda45bccb8b94f33236c3a3fa18933d54ad972e97c12166aabd509b5adb14199e4df99c503186983fb663502bd165af548bea9862785e22479a0c9d3577bd61789cc37ccf9b7a4d2ed302036b364e8cb164cffa7de1c195ec1a7acc2df6f75e78125aad92aa769acdae0b4f7a0ca157c6abb8b0afb8b5ab652f6da11d4bebd3b56be169d4caef4ed96bafa52c20f5ad1cba2bb2a558781eae7fc58fa16cec335d2139a67f6d29564c799f159e7c899157724f4ba9ae4222422cdd527e9f1a2d151ef4f7f69d63ae59438a98c5293c98fe55b274699fb77c5258fbbb8bb81a5244875178d45b25ebe5f6a55ecb41019b5a6929e7ce3daf64bce9a080f18447933bc51a5a5e6da9b44e40d7f7c6942ba59cabd704b6cbb17c0d19e77ace31e1d1e5c9ff5db332949da400c6129271ad6556c7e44a95125c53a66b6fb15f4b764978182b47a6143e4c4d5f7a021848588e3bd77336f5966f1ee141ab5e394749e96bbd14d9743871b80b48809014e9a09c3c99179000217199921614d97c0a0c4880907c8a89b3410284a4c8b7800408c9e6311c5f010910121221679020a3f849f202184640aed027d68e94b377af0829175a84bd12b5134abc7a174b76f52f659177e3e298288e10c54fd246d3f126c2e312edcaf5ce71d93d51c018c2f3ca563bf41823e6b2278487191de52a77ead6f64178d8420bb3dd713de72e26269e2442ca20e9949c94985c84a80669e3120718407896a6a397d663d774ad7ff138e7564861fa6fda18fbe2518ed4ea5cccf9fdd8ebc583943371b5b79a9dc2e4c5ee4bacbca9e6ccdc63170f6a4b11638c57356c0d5d2e29481b17d743178f630b295bccd8fbabfc5c3c4f617e2f4bf94e531b2e1e4faa9ca7758c6953ae6ff1a087d02eb678b572b9cb16cf737fccd462f6f9cf2113f4a8c59388cc6153c88f91da448b27992f959c3fa44cade62c1ef6fbbcad6cc5501a244048100c488090203448d03883c404e5a444c1d043168f6b4aedaa7d98185d4a9c9635e8118b0737119bdbe27bcf7d535c6af480c5d3890817e3eef3c364e24a2e19cd9a917981c5c27143a3c128a2c72b1e645d975c79ba6baabd0bbac2a4472b1e7cce217eecbda6ef6c611651a6a1072b9ec68e11cae45e318bab78fa93b9d7d7cf11ad87aa7838195ac9a94c6d5b956216d7402b158fdbb78f09bf535173d803156dd123f6561d7a6b6934988b892bc924448f533cc950115172cb8fbdd498c545861ea678def6bbd5d6a9a73469197a94e25144f67d9ff2ed52c9611653e60540309d9218704c4cc8200142c2060910924e1c24404848809090083983e4510817299ea4f0bdebe2f56edfb5ee318ae71fc2d7ad752d6ab56b6c63a187281e97bee94a8bbc5a22e7428f503ccd5d75738b8bb90c211c7a80e261fe9e35a96fafd8aefa44635cabbd37eaeae189a79f4a6fb5c6b94d394cce65d13da7539267e8d189744ea5a6e24bdb8d4980245e7045a20727fa3da9578f7875532bd22949bc6ca2c7269e7eadadb7f8c8a9a4cc0cd143134f3265afee35ed7bfd4fa541f4c8443e2baf94b88958f3d638f4c0444a8cd2adc7e5b71af182e8133d2ee1dca85811114a4bec22c5e89eaee69e221f7a5462a15babcafd239690e9aaa107251043dcd0b9f4e278970182174c49f49844f24ded982ae6d2578ba187241ac367cf9e737a89f99148b676bd7eece833b741821726aa861e5b4839bf428f47305aced8da94fd1a2a06424222e40c128b45103d1cc1cdf5b9f6efb15f2d9db11aa11aa95e291115552ff74a4ecdcb9772849e3727f460c4b3d231d792b1949ead53cce28a428f453c2b3dd4ee5b3144b68f611695c502851e8a78986bff6c19b7422fa96216f1dbb78c2663b1582c404880648894a8c1860bc858c362d1c021e4dd7013140059813f46d9b0584cdabbcda370180900113d12f1aca333c7d6fad5906143c4a33875774b86b9cf9219a1c7219ed598d663a8b964285f9a420f433c08bdbe96cb1707a147211eb4964ac9b117667bdeee4188871da1457cc574aaad84592cc22e99ee336b582c5ae8318887dd3bba94f21966b187209effc79bd8eb6cb9d2f1a5f344163b5f46201edfb59232f6d43e97dc03c4f3bb1ca94f8456232ef68767b9332a62d5ac1effc4338a4448198e1da48d4b911e7e5889ea547aea9af6c279a2d93cb580e8d187c71d63c466c839478e8b593cd16ce0f0342e49153df8f070524adfc2874bd71d3ea1c71ed6b9cfc5563e4f45c72caa4d07c58d1e7a78c9b9d853dca81ebafc4d0a4763d22c9613cde6592c2442ca203131117206096e3a289de8918746b9d0c2e7efaeba1a0f491df357a9efa5560bb348e23685e4a404c3b1bc41c2368504a94d8f3bb45b9f0bdd63a3532927dc49714146050b8d1e7640a88d1225a530f1e2c48f71a75ba4308b2626de544605d9a30e8ffb4b4edb72ffe81e6326260ea42fb8b0071d9e954dd731934b991c4373785e7bcf8cfab9737f6d7278345ff9feb77a7c6f1e8787df36b627668cee5ee1f02c43f57c0b1fab3f4b6f781843d610bf56ee54ef86e757a3aa53b7f8b94ed886c7d5b57373b6beebffb1e1d1de7d9d5253abd5ef5bc3f30b9bf37fbf9e1a1e778ab9e7f0952337f7343c8dfc88d9cdb7a1638d86475952af2d6f668cfd199ee42fbd959263de293136c3d39cf1b3e45495d7525b8647a55bfad86ac8fe35191e77b75a9b367dbd6378b6213b73f6f80ff793181e662abf575752cea196617850b37fe4cb21a42a5782e1f94fd618b5b79aaf94f20b8b38a14a64a478a5d489fcda9cafd6b8dcaef3d6c30b4fea95da36529cfcde73971e5d78d65d5b9bb0ad2f6fe8b9f03c8532513f5baaf1e68548a6849392b08c1e5b78dc2f6cc4c69c622b6f5a78d05a882b21cba60925a5c95cbe959870b2f0248734d55a8c3e29851e161e54cd2d6eeb7425a3fb2b3cd9aa55d7313a2b3c4be9225faad0e34d5e85a7a977655d4a25d53a352a3c8d9fed924bfc5831f7293caf214dc80d116bfd5c0a8f4ae89bf05f42895b76141ee61ed742cbf5abdd85c2d30db5a6d4574c6542fc8407bdf95aa510227795ea84c7b17f42be1e26dcd7d584075fa156497d6a44ed4c785e5a7db52b257b4f492de151e8adff94fbce6d6a253cc9db4afdcbafbe99a947121ea4cb54a95d0a6dd2f6164b0f243c492da3fbe7b5542fa7e4927281f438c2d3ca793e54a6789b43233cbebb38254e75ad16d21e45789a7af8fe94a2a536296b430f223cfc927653ce1ce37b6640e83184a75bf1aad5103fd72b7d0f213c89e9f6b9f682f0b8656fff7c6abd46b43d80b0d8282944cddadd691729e5cddb612385d25b52bf78da4b5e2b933dc4703176c11ff0f0c5d3522ba489a5e4e6d442bd7892fb47b6ae1a6aaa1d5a2cbd041ebc78920b936ba8d40e676512611c0a05a21886412832b1682500e3120030181c220fc763429930ef3231140003587e5264362e201186a2a1501c0e8542410c835110822008c3300cc030182662940e01dca04248b1bef3e175113c11faaa1cac56601e1127822e7f007831ab5f308bffda4b91c21a53d1273faeb048024dadf5f36103eef9e2b24e9aea427c366049462dc78c33d757e576269d4bc810eb67a4b49c2d44f61b16cac6cc398b809db0cdce46a0eb2be41031f6cd26922bc0b20ae0ff376f183516bf140210fb4beec9610bfa1d6a4c7e5b183ee0a8985b04b8af86119ff38adeb0618228c5b552683e9644bc4931331bb8c67c47d3a2ed64b07bb7d39993e234ca421ad85b0be2df21d3bb7687131a912ce3ed9fb77a501cbcdb56b0d0f72fe81b5ebac003fc2c5c5541200158ce8058152bbbc4760fd78a510eaf7ba9de3aec70fe7b178a4906ecd383b1e71880be1942b6bbd7b1ce350bc3af4b1da701d3e95c6726777e37a93e8fe87a573576093fe01d0ceac51d010294092181145a2e10b8cb18ca35f9da8e9e072d1115aa6db6801d6265fe6654da58ace7e7e0bc8f59ade44c15d3adaac9c93a4d93f54d8a30ed2773f02e1f38df16efab3e697eec884ac5228fd43cb05b96a859a14ba2ee1852b1d63c00e69b941c19e164c6fd6e59b1dcea2675237087d4da5571772c3f243128d0a341bc09d9e8639836393552f2a1ec291736258aee619a2645af8cb189442675b59b8974ae68170d4139a35dd2a9a3a9eb2c5baf48b5a96ad05c5e1740814ceb0c1b3c55de6239d4c1a9b220abc4ed38e01a6f8d20566963db19653a92677f1600fcb19f24b6f2c286a582d145bd026408463a95acb3774a11a4f5c522dc20e06392c1641f8a1355095a0b6674f6ad533f4a3bd0a56c39bc5f6362d90155cd96d0ded09ca1c7e8d51b45833476580144a9bbe2fc83ee235c2194564ea27ca96525cb94b804c223e07f816e9714003e4a81fe0b38227c73d8e937c6cf79487eea07c0efd73f86483312f7fad79a14488069330024fe4b12d21956bc6b2f00ea119a770ede4f16eec2b25b6b8037e639731934f8173032f8e1f1ee7b6bb318f278722c972214656eafe126f3f2526cbed30190abd102fa745fae6c05a15076f2dcb1b3986be107d11ae30b26e001c81c368c01a1c4933f76f68d2d902467c2612e8abc29189e416b5025b720f92c532fa0048eebb69981a2056142f366d6bde067b8504cbb952bbc93e09ff8ddf8072f2d08f5e813eeb52df348a3a30b3f8247cb3a0686aede98e8f28966cc6ca67a05ff3f4f81e27797d77a5e65ec12da244d38b1d13c30bd164c848006f0b8c03ae08d1e6a31770364864242946305d8d0357dc878c8721f332c168d6964d16b313636a86723aebc1f57e538d7ab0d1fad7da06867f3343c288832fa30fa30d65c1da990d6b2a5283e26420e47aacd4aa507bd4e69d9c8f9e010baf7057cf8220ff43397e8a609d9629c55f092d6dd0ae3b62a38d59fbf6ddfb524060ed8ceaddd3bbcd9d16c7ce86e79b4849a6923998d37460f8d5f648e1f31d38ea9881da4922ea7f33ea5a0b489d72502fb4395b9c8ec3d155cedeb54cc3a6c50d1848ac1d2a96c090e7500086ffa32343ad91dab7a36aa6974374cd714c15c4ca2f1befa2645e6f82bb4194f27a0e448e3b6909039412aaac130dc57ab1206c21524c107a2883fbda32580e9e502a38bb4ff04097841ada43acbd6dab6c78fff4cee1d16e49258f0790066ae810f86dc3307b46c22624c4cdd15898eed119c037e495dc632b8b14d62b0e78076d3aa40cb067a8b633a0f24eb38b69f3512b37f8c28fe231145828990dcf6fb305aaa3c6f3f3df4487f87edf50d35327978d07caa1daae31477f68d884d0e8c7d0e031ecee70944aee1c49a843013160237f30fdb5180b83e295f80bb8d6a670b162ecb5e4957c3eff53a8b5fc467f80974e030ddeada6eb654e0554669748ba90bf163f72e8b617bcfab4b8fbaf4d55d9f76ebc9ab7ebaf640d7bdfed2c3deeac95bcf9eda83f674a71af99e1943bf351659920427817b68d7b4798433ffdcf00994caa78e07ea641bb7199b2919d35702194efdbdcc74386311d95ace2a016bae9ce18240003d05ec2140afb0ae6920ea4b2053f709ecf26680b7cabf3405cd05b803ffad55b5490120dd10e85dc8bf3d419a5970b75f90d937c621fb19c8788d066b240e1c016e3a9ee667f08bdb132d80be74965e1404b4820f142342729b45c15498096101b7aa26bf072cac9aac01634a21af73a8e900caddabb38f0bcae3555ecccbc7cfa3fcf7cd850d603e14780cfd31b2f66d8afc4d5390190077fa6baa276044da7ffa31311d41d9a495012ab94d57d5203ead4c718c9cea63542ee05c2e520e61fb001a52da9e6b00517a283aa900a0c9aaed730f72ace92bbda8db95157e34beb83f52b925170055a9903204296c2b647332b7d3561b9b9a4251bbf05c7a9ec14f187fef8626ea8a0b359172c449eb55b8c568d596ccad5b302c3ff1a7ba0c531d528f0cba33603fbcbb768655b5f0b34443b5d3ac0b247129ad665a8a092953628660fad6040e24c514e277627a95a52a90db182c30e2449b552bba1a4a1c3be7a8bc6dccc9a54fb220701f315bd293b818eafd842cf95f4a53d00688f7d3405ce48849508e17cb99593636013a818ce438999a13e978503cc311b89814f3caaa8ab8b7f4ae3bb7b6065e8a6d28049634f96fd58dd71668669668a810f63dfeeeee98538b8dca53c8f027b9f5c2ff53ba3ea91e51149a8b11ef35a468b1864a3d1a224eaebefa4ba569c74b551012b0b1afa39992ed8ea59f519ffb9d1adbd1cccad0ae562f6981128175e9e1b350066d9252f85c9cc4fecfb1455af150cbb87ad00f52b39d0a26ada20aa42cc551dd18315b083832510cb6fb1417c7796a8f08e8f49db945ff0c22a0b182e44ab39b78d4f21ec22fa08ddb9cc1257c89767ee6106f1fd97d53435be77d6586f08e3d9f9c1ba8bc52dadd86a9ee919ab0164f359181db3ce6cefc4c2cb5ab2b88e3470d77611733cb488f015127edca651b3a3c0a9abcbc916d11d41c0dbb0f09132b018d9d902a684c2e608b390ec33ae0265f0f3abb480e1f3c611fe90956da923fad93534b55e50f07526a173570b9e894355b54f0eaff67c5a650715db5dccbee5622c24506a22e94855a7a46fffd000d3b009e642c8887c322c1c31c2d3eff9c605f30060a4389b83d95df3b000e37c9f1c0668c0ac05e45ab2601fcfa87f16ec11097e2b3aeb814e89ffaeac09a8517eebe8e790d7bac6d0828077215fc101c6cf28cde19bf9d2cc9d509eaf22627742dc590b04b94405dc05084520391136ab4d64a629faf37865f0e0fe358339d782454d5d4f3c22de86ff0ae6139c27b64728eb0cc9de6d7fbcf682234b60e04f6b25a1c6d19ac7136e230b90c40f0c53f1f9a12c8230ef17aeddf7b1d9d145ccbaf758f9879c8370d41840551c4f52a8f523c54e5f3da3849d77b0e2f75372c8266533ab948cf275f8788dfe8709c31005f2cff1cddf051a0356329b2e6312e59ebe961f9589229940f479362c5fe75728f9d87668a8d34af7d0f5377e4655d10c97880d368e0cad0b0e8a2c23c5540952d225300663d9056af3566bfdcf2f38d0b06f5bb204915da3417800453424353d9e365d31bf39fd7c5ac62e81adee6229555a7b0bee74a65f09e819360cadba78acbefa55f9d5d8c7510d7a85ac85c4011c6e0d0aad63d08d62f6f7c629e6172b566444ec43a066113be1e5c4480e82ee0d3cb97d96a674c7d99bc61d3ac83c6a0b3893e435400b525e5b120da0bdca11420b557c563655a62af43c0a7cade7e65c01d9c77b4398f7ac7930e5af9550e166d0b1a220e7f7c7b8599eb674d428bf1b34a5c750a192181cff70edba379485821461d06da24ac500daa143198b46ac75730ff67d6770aa8064cd9865a11464af9061673d65d7207d864af2e6c148b484f73a43210418410339ce030d820d277661b4582788882e59bac89ee42c818ed5e67ad3a33616255b8916574efc5b0990c8e7d9d6900ded5d4c88aef53fa5616e748c1ce72524535c10f077c458d5ef441b605679e0e9a095f2d9c0496b53d881121697bde0ec2e8ef5f9057ae193e273056f654b61aeda694ae4bacbd2b1f2b78ed15540b444fffa7048262dcb1b56c9fe7daba8fdf8d4ff03dfb90a1d4e68618101c64637a28c62ff855f96d7476e1294046d8759ab05084dc872d4d25b8c13ae03e4f1d3c75efc3d24d25745e84ce1fda919ddba7b39620b0b83fb832214222212eb57df2f987f4f8ec8790a0a2c9551f71907e7abaac2ef569c8740caab5f06150ac0bba2ca9e0fb68cf2e08ac11d599c518afcb457a25d085eb1a55a5d97fa655bd306ba5ffc04a7da1b69f6d7ca1dff6b8aa113744f9d7abd9473be3daadbfd13e9995043c02fe3158953b892cd21faa9b5f689911a8a831bc4fd49f53c78396a66e15ca3b5f056829e160b9c8921933101f683067761477cff8c3d2d05bb8caa09809fc5f25963d23433393f1a95b82a3070766f858085a090b003e49552d5e21d81eabf53c85862f52fb9c91eb5f56b8eb7b9782e56f9dc52510ebdd07e4a8e718d0c1f08b77f01b622eb59b4e4b6d2913fd4ea416d1469151215e8574498d4c8bf0ec1a950e48bab1442444485d0db18fc1591fa87901ba65f270e03630fcaca74c48c52d414f46180a2b5eaa3bd27700c747137c43550a7103e894ff5e9aa095a2dc64b7729bc9e9a41887ea9f9ed4821284ca90ba493c7bbb7b16b297d50f6370e732e5e032a8da764807726bd99b95d98613adc43bb9222392314a03a6543a889cbc8a78c825120b4660acbb6cab5e3eb2579c07663a0e83216c9904eace8ab19fb8da361b541ac3921b675c15bbdca4deba47fba96412f6e115de7198927bd5b547d54017873fbe92e192ecc5f7afac9e6b98b37d7dc3eeae6335741a5bb823c1dd10d2d35822e1233a477c263edcc579fd864ea2d424d6bfd32f554542954d4632490c057977b4a61c9ada5a4984dd54b79d9e040a24082a624659563014456450f04a841be86dd668d8b40484790e900d78f2b8407efeab58d8010fc0a74f075599f429bd0eab799b4218d94288a9f09f88ee110f3abd450344f7dd02358b8b2e90d68290cb332007e8c3a0c637036134530c8ccf0cf070db381243044f579159961c222d61e918e628b711d5fb0d5414552265517c4782fcc650b4f3655e4e1c656f20926169ef62e515a0b4fa09fc0d20dca62a52d2ed2ad6216a3d3f6f473b0c0db4337e9edafd5cfddb9d4d60dbedb0160e5201412b7397b497b08c84621f9ceaef8a20ead827b13e91850aef04e04cba8b433b3dc8b08a84f491f4d73b78ca4e6a07934306077d65f741a762c8da6c5349464412ad021ab2c4f849ed73a8225e12b734464166d007d1add410e0e58dce305dc4048ddab00d53435ec3f89e769d8e6f666d0b7a6a3c7fe82d9e1981c85837af47452e27f9ecd3c3b620206ee4580bd27d9b91511671cd78b6c018e2053ab44e83a7f1a54e1b9e9b54b48f41cf18b04f3835628cad2afac9af817863e35e1821d8437450eac17c3e69a0047c514014803a88f4c22c7e23109e51330b76c92aeff73530551424e16a6417641f82b317f4bb5bf580206b5555c8b3072d4022a90ee99e4c847053af3ccd21024448d1442afa53ef79709676885cf9cea6f1448851421a81ea920e49315946d0a93df28e282504299ad6a3ce4932528ecc128dd43329238a13b9110b5cd2c2d8eb3e73310daf3994a588349c32ccde119cac427308c94cdc5fe0a68c24c7702404c3123a48ced85335b21b8163c1813b6d8e6622889053b1de0a2fa313c49427338926d54a828852048b2ad28c1424494ab296db0e4c6e578de0ff3dbd5a8fa707c24be94679d54d571291ac266854eaa2c77986cfbc102ad52d7772c93309a33148654bded7bd997dd5530c8c112dd5445e118b1099f1ba343e448308299a48457fea3d0fced20e912bdfd97cbc38a45f3237c2ab69ba91026421415ced392f8fa5761fea38503015480a904b1743152eec82fa43f473c728cc195d9727f1a7ec99e0d1d11e2465930207dbd562bb870987925599e9f6c7ed55e09436928836d9ad4d009396a29cfdcec787c455fac93936348e32c99bf88b33b5208fd29287f82bf76c385e331239958a9f611387d10f92e2c1840ca1e594c23cd59b6747e0a24207b6c54a348bd822352141c0953bf0b46e1eaf9ea8478507d1d5bc9dbfc43d7a52691abebf633f7296048da67a24cfabf51a93f2d5647109f0123689c888a864d775029a09439240786988949a3423e9641f01de05b8d4c295e1ab9903f62a70723b560e7b17f04de2e27eea9c06662821a3f22fab478307d02579637f754f0627b4b3c8c1ef5a3eb5605843cf88e02c69bd3a3d05801a7124788a7bc03d5740ec8602a4c151028b3fe14a1772addf8989eea0749fb6452a27845bd0aa16dd4639fe86e2c5a63e11095acf6924e2b39a4cb138ecb34a2b81d35a9361cbe994c0bc8712abcce3c4f52705b5eae10fce9dba21066df6bad6088ba279be483210c1c46027fb1d46b810d4ddcc8f59ef50a9c91cc78920690615e3cd26e2394d45f84aaed60f9769987a8301aba587b24213524b79438b46c5840549eb3a86d2c82636024c85c52a43a1fedbe9144b62ee5e027c84e492d0c6bc8432bdd5bb99b47429eb5b9f44646e6e3b85570e100dc3882ec200ea3121ec0b3f150793c24c88996119d04b2e286590998254e02cd7b5a794944c3eb9c5b13235ba4ffe804f71cc4636d40aa5bce8d28bc756a350e1dc9d091e63e434132d8aadad37c9e48c88586b56f1d527a9efccef176b4f4e2b6ab02eec9d22a2dd525a4b6239c3ff7aca4fb4ed4268b470f5a4e6068a22640f2da75067f3dca1113aeffd33a01cebe96c86c2a1ab4b24d938dc6a0f60e66016683ddb052d8cb5934049114227dde02551c374c74cd379a4f9e5e8820a3e8b11b8319aacea303a0181295afe0cede5e8c447ffd51b893ad70487ab2980173baa3864468acee3cfeafd7b809e5dace297879e7ebde973f3620be1d6ad74bc07bbb978a16d6d0c0ee989a965c3a636b5f2949c9bb3f1ab8de04d16797c8dd2b5e28329f83634235a065a2c21736ac607b31d7fb93324d95a381e32a7264b2e813270a4964728838e00403e6c61ff2fa756d2dd6cd64f9ac0db1d51e61da99dd20f6addf23ca3ae237f944f8946f94e2a4157564467dafe9f64d5b11eb986cca985cc5ab7519c1722d1b9a90c85f4f2c6f8d3e51e4484fce17c8849447e4ff4cf1bc2403527627be21147c2da1823f73425b04cd42a0d465ab1c93a23ef95014df5a29c30337efa28caaa47273bb6c69c6e210adc0f5f596176ab205e4668087180228ebabad695dc612250c521f1a4a79055c4602cf5c4497b6f1818199b30003184774587f4b5690f23f859294940401ce0b8a6c14a65544ef1c178398af89cf16d1ba9f66b464eb5e5516e983ab59ee58b30abf4131d5a0760f9f60747feacaa26974cc5701a46d8e931dc00d398ed0b7a631b929c5682d92e26956d8b8ec692df361e8b763779217af3300ff1a12e926b380385a85b3048df5be31c19ac54096e98b638a1da7504cc710a95076644b523f3dae12dec4c8482cd0727d3d7ad728b8243020f84b87382813e5defa00e51009d0a9ac5c7716d374f06446c1ab8cb578260c69390ba8b8ddaf7b58db7a438b4718773e37167703834910d1a14c9c4937fe086e51efcc73169dd76e79eeb85ec202a53d126f12a904f18eb80bf1e8628a162be5729911c111b614fe7a840e0252f761ec9163c927017591b3569ae94a8a4160e7eda656e026a4b737ee4f419411d40237ad4fe0911172f64a12d72ab7ab3a4b39e062ddb6ea020ed4244525a325bb38b44786f0b322b65ffd06953e451ae528cf07b13e199b5c3c783ed91c5b21b75285e908de09ed9673f31b467f2ebc8f654b3e487059fa7c30b83a8f670433bb198a15dab1a75af7914d8b584d3f7b9812ceb16e29bf9da9c3c7bcd966802c8014a71a0cee58be87f4219fd10e626635f29ca03b4f238801f19b590e2d177b2d16bc3692648f91a2c57a8d5410ae64080a241628967634537ac3bca5dcfa3305bcb084822db32e0aff417c1490ea14e5c76a75b6f40b44e1a581c7067142b0c669292508953aceb7739345362cbee6a06c96345531fa333e162300768aa2e4f8a40084267c5edc75328abf638150a1338ec563ecea58e28d54664b6a0de6441d9250e26d7020e07d06c7293586135a60e090eb7b2a8513576837079312a34586c5249406bb420b18105e982196a9a60ec4791a929b3c11aca0e7e8df0c3e0ec929accb096d425b051374171edededd009822d7d055bf629354b4f59819292a64282957800904c2e988bd1abd7e08704dd416f2a494a55162ea0cf6fc982df31cd0537e220941ea4372e8ca83bad2935c491125b4480878c5fd643fd84c8770d0cf6cb3f6b4d11d945927b828e8fafef5b998c6c78e08b2021e5b40a2d1164ddfa20a533bf896724d905fb6fe112317b58d446eb2a1d1f3ad2fb6663af0734f8907f8ec21ff86185bf308014a82a36fb247dddd698ca3463e962a7888778786cd307a47fe9127ebe0f5803c7dfe7ada84d1df0573a58b57f3d161d4330706d63c1fe05b846c8c89e37736f7476a25435cf30680108131f12df5a8203d0ba322f8a46491c2837c2111e006f5d44eec598891b79b921cbcfedadceb3e4b66890d42e7b2e71a3081daa6cb92bd9d49509ca70a6c4ad62c484c22987cc4ef3abd2c4a13df61bc419a413c9b7a4e4a6dcf2eae7ae8679338a4f6a15b1e3dbfb9f00020085066496dd0134a774a5207e80b097eeef07912cada0051596a114d348fa499f64944c5290e34cc5a1f12a9cd0602df7b197cb7a19c92042d48443081a01aacec94733de837583faa96225b7728dfa95b3480096eed869a9d99ea12ec9f309d66e51e18a6a43430685a92883a6a14adae97168b40ee73ef7695a8292aa26054fc4d8a3e78280a7a38c04a850eb140c60ec7e494031586da37f8446037686e114467024d927108e9478587c8539d94a03c21b1000e4756824dc4f2842d0a324767e62e8dd9739b28792d77cd18532671b1437fe667fe7d030e2e70187967de7f0101bcc79b0d2d893addf15a938ff284e1508308314f3bec06103541bc5bfb464f9b2ed1fb1e113d5bfce6d1b95a7e73e135aeb1445019c0aac4cb50f27517c5aab96cb08c70595ec08f7adc515c4bd4313f7a9fc4e67f045215248d2608ff2784bb012f7a6b2945bd05a3995b52e4b5e7f9a6050aa88e92aa5821aa16f230a8150a2f48fa306cab961d02b691ec6a33c6a2c9c121620b880fb612926c73ae85ea0546d84bfe5281a33afbb875593b803429972fe73e868090f48da9cf0ed0e882cd2b1546c4ec08d1fea8834a9ed488763f4bcfcd897a8a2b589e6adac84d6cf70d4242d4d65aa4ee447f8b5e79ee93220f11ab260c7cb744159438b93a5b9bd304546efba78d036a67f2efb0dc8f2934366c4d9cff9e99ee4c603105529e2b9817c8ecce7f1eb1185bbe93bdeb610af5a2b732af14d85ea7124c55e80a52321147dfb0fe32549768a48b44a40997d55f65b835dfd7bf6915e35e243c0e8d96c65bab82462e6eb4af639805aa72ca473e392644aa2fa2a642c7cedbac1e1accb514d7d167c47c0e5a138a0a7cc7115342ef96529cf10631960d80bba0ebf64449c16653c6dd0c054427c0c004004ff0fbb2c52acb4f32ee834a19f0374859414044ac13822389e21f9056b7cd0a24efa31977359b94454dc3180eace63facea2035b1572a732f4ab8df0279ffebda3b14052380cc2373d8a81f738958e929ffe32112e00079d91c1cb76d69172a0adcfc089c405d216054ef88e45ebccad00b926990d064c6f0a3580b2db2f0a40a8f0374ad2ae7639681998f8568014f2bde91bceb3e61a29a4f48c0f821ea91b4187192aca6dfe8a40d2f781a5a0d87c4ca5dff22094815423bdb9aeecc4ee19d9d030a68461f13eca4f7703b43285a95aa680830ab52187f87edc4d51a7fe152f37206fe2861017bd7d59a17e51be7617b8e1046736fd94d8b08a20dd194afccb6378645592b992e2a4fae30948ad1bc8190887e6b1d9f9d1c77ba0a11f146a2950b50aaad6a3e7b76964fea5d7508543ebfb7adf7d05e924cc2116929765935df7290be77f0c7c02043a34b4329ad191222fe5abd48d9c326ea5bb37dd37e23c66f85c21bc2452ca5e46d14bf9fd4dc9d688e4face42348ca27e3811e6ea158367be311a34457e619c298f6e0505eb51c6286e8777ceef4bfd79cecf4f7b57410db5680154fef144ac3645ad15a5324970fdd1c96d36ee40de838c9344ee6807c5856f7e072cc39884e8b95483251f418fc8ada22e3d79e3781adbfd89c319d5bb247534da83cf7d81fae55ffe21797d6f961553eb64cdf62b65df975269b0b0d2af1b045c03a649b674c3e1076f15aa23114d3c0026fa1d97b98e0d5386a905b154107231b71a5661e4133f11894e79d6e605ea992722d6f20beeaead136a0532b6152d60d0433b19440b3ac09884755ffaf22e1dac31ef252ca322d5eefe0c513f0c86c4c128a1c4d674f7f67f34d2516d32aa475bcf564be3a779b4b5fcac96388d358fb2861cbc6152b674191a06ce7bf6d4ee7d3751e4f60e84c2b6807f00cea0cf013486e6db341329351e5ca9ba6e97ab4751033bbe35c964d2f16d8f6c2be50128bfa9710208299b23af7a12413d3ddadfc8704a760e405d8dc7d28dbe831bb4399ce60e8f4755cdf2d9d16a20f1c18ca3e5531839e8cc857918ea706124b4761deab4c3dc82b0c17661fd3cfbd0692aea5440db159a0dbc7d6b4c3e39e3ffc2e0326ae558f44311890d9284ccc600e379dcb07cd8fe931c785122b632180163f761b67f721fd984e5b013e6472ca81f6b693bcf257cad919e83d3ecb80049d5bddd530139a13443a4e86090ae20a3b89a3d71e412b63d19c048d4a23abaa2c2dc239018eed8ae5244171e357d69d7866b50cfe85e5bf1ce6b2a58b945f22a9bed2f788af3e84de14570aa33b04ed2e8f65d3f8792ac3ca1a83777f4015fb630b08577f1ee73fd500179b53830de4e6bca41ab49fe81f06411787150f162d595a6b2ab3640349260a07a096514c62311ebc1673294670810095226b09a6e78832e37132d438b2da3effa3ce1b0e67710e95248e6a74e895cb43f410b3ea48863543986895bd9ea1016862abed3084c9dac55986981bb408afb92e84a95cdb78d79b1462af40d3da9246b31189558346dc1928122ac71d44a808ddfa5fd57e384d2f4e577277434932379ed995a1a19a5e1214c8e9218032287541cdddc3ee8cb990a8491f3ae285136a4eb309de5ac99e074ab4e43a4ba6a854ded9d2206dc69256b8f289c30c96c751c27c5bb09a6c38329c2e12318d7c76cbd5c0a8d6ebc50ca4beb0314b1b622df52da8e11e9f94be963c0c4dccf41459a8b1dc96968779ba2fe6b0eca5e9b80814ac78455fe2a4068dc5358c76b10d4748cd6b6ea52ee57bb3db16eb3a35f21e4760a514a10e0768d4303392be2182977b39759cf189095d6291afb5333b1c85eaee1dfe482fc651923722729b7934f48fc00f02a911151605812f19a78cafb8cc78e154e290d0c0f5a900e7daec434c52fcf1ae2ffe92425515be9fbcc3cefff0c7bfb05a042d6ff532a1a9ddf1f5cd2928e4629f60fa91780c86e27216146bee94d6fd5e667e3b95ee4c9ee088bddae5b34cd87aca5b060ad7dc1ef44d4dfa7704a2384d3b525d5fb26d0d751e2143266b5e7834a6a293543825559acdd72a4f34e3cfbe7de6f5397396e85937ba634bb944777b858e736d8e361a2f804536c01a4cacea113c8e9a60d5dab223006e850732401d0190b8a2546d2bcb587210a8ef888d18634a44b12ebd6139b179d35c1d8047a479dac935361d4783faa5a142845011171906a83fa655a628307ff3e6a89dd9070ea12ec0f6e25064dddbd040fa98754ca96a8b3e4ed4e6d89aa8a014fbc2d51ec43d542339df5e60f4cebff43019b02815f3c5d6ef37c64397080834bec527325b610f12d884becfe879fad7189ca4d52841d59359b52fa22bf022f97d835cbb9c4e6502cbd00efc82b375d624728bf6e7589baba0ba61a5ce212d5251008582e4f07c26f412923570e613733ad32cfaec44bec0e9abcc43e18faf6b0ec5ee70bab06e69740a8e364b6ec76a3ab445d0dc05ea28e3dba97a808eac1d6d7f12d1449876126d2eba182559c8d46e996902c7f444ad4bb3344830dd6a726ac67e0c85625a7c88ef0d331ed14fbb4536ccde739a4fc035fad3f886adb6471f2e81978600e6fdc568a313e1b22251f313c843bdbe9e82122e2b9fb0f32b85624573f5c49e7794e1bfad3101baac703227e661b9054a8988437845374dd0b898e99e239ab08a7cbc6cedbe8e9f20ed10c3f8434f598e20350e2aca2a4592116182ffc7a2803640ba32d2da6748482150a7ec800f59e401fde3bd71b67112d5aa9ff8b8a07c25f0999a61d022ac014c802a7f0283e80de3ba0a0015cf1e2f7835b7ccf374fb39335e665fa8eb5747f98cbf9c125aa49b0d64a4573f88ac7ddd48cff6817a38a68e81175b5821d674a2088ead54ed9bd285183d79e958bf4aca15a45da64fcc5e1b74b9add1a06d36e93570e7275821b38061573a645ec0ee99feb7fec71b9072e042b3f5b47ce46cbca6c1e7f4eee6e3bfe96ad976e8748aeff38deb2b09dd079ea70fa6f6bfcee96e70399ae51f7e88bd32cd2d1e653d1c586e2af8edb3883495c5b1b0afe3363f1132434d3f89335796526f6cdaf89c43deed28c6db7edbd8fc31306010a46170965da494266ef1a41b681d9078cd4341613229394298348d3c5dc406c6e97245d979bb2c5826b581948b9925b098fcf67f31c63896b628cb36124f2c43a28c9a300e25ce143ad78a1ab4f081310863d46fc1839da62b2c4017366cd919e1721967147db3dd667a97682c83209c8f81b3fd646719ba3c7e575f8203518ac8b1d5cdc73e9a2d165b067322bccd7cec66a6a1d647745f0ddac8f2b32f0b689f3b2a205aaad438dc512293a3b6e4c2bb473599bf387b5f649bedb22c5b8f6f816eec7c7baf2bf53c4d1b0fa98ca7ff0958b19328208ef6b5676053bd4c544a494bf6f78aab3fb1649ff22ab038e617da96d266422578f3d2562191fc7a8b7ad94e3ff2d471aee1392e0eb7dbd7fa21193bba4ad91d3dfcfc5d9144fb6ccc3ea2039377b2f15c3058de506e42f1f4f3681db1b059af5296937a804b29a534d80c51cc6afdf09dc87dc3cbb509bcd6cbe3ef2807f0ded8d032d3b34d88cf20ac01f599f20781d30f0f69b81e0a3cf7125a875779cc1d4fe6600e9411fe5cbf4292e4d41cd7c54e8fe4b5398e7cc528f33551ea1ccb5dfbc69e9c8dcac3d326dc072bf065e33e711a7d27f93fb25567f62a6380e78a56f062973fe5e57d08a409c490d07ef4699e2ac4989a43025f06b1e41ffa2545e3a859551a0979a9725f6bcca603665ab5575691f7b0d90bf62fab1e1ea60f644caf479ccdeb6863672177a375440106dc2ed93ed1f7a6b8403dcfcfa8bbac4e02d7683f6bbd0476ba44aa5429828d64486540f18a7ce6ccf15fe23ae241a2f1ac030f503f00c06c6c25c50dfa5d1e5705d08343d39e527245df77f7f1169f68ceeb4767bcacbdf53756905e4fed9c7a80f827f4ad883bef46cbc778c9341cce256cf2657ed5883b2d65080e8a75ab8cf5e9739c1b1ecc2df440bef5ad0781bd0c4a4252398f2d7d20c07e5ee8438c61f12ae0dd2eebe714f1eb129f01e13fc10127ddd4adeb6cb798b0cb55d05ae046eae3d6750d5944cc3661c3508abbdc6a0cf2a15845db4b67661e6c2555dc73f182c5a040c5f1be9205e9f6384f08b584d98001d5dd683517875a7599f5c07b3581bd5c422ff6b577a2ed4daedf20533d1087c3db0881de393aa875003fd5618756a05123dc0bbf2362062c63655235a4f658cf04e132f2500571aacb7183644480dc091cb5a2698dcd6dee58582baa6c2130c88bfdcf48b8414ebccb76a960a403822e87ea1af4d5571747e4d65dbd338eaa6e3befda39a9c86d6504efe8f55dd0734444289c6f0ca670892bf4ee33bdf1426ed247c3238a3eed7e47fd78e8a91893b39627b478c380f4fa1564135197e9c7ad317020b1f7a454697c3b733c85d85f5ea1a0c06d47bd3481da79e7863d3fdec1254f8c0d54b33c24b1c1bc0dc5544c59fc17847747b78d52c05ffa0c1d0823de355ec1d669457bd32223f6b97dea9029d714b1a633e118c20606f6d543845a0e70bd26fe183d35f5b025a46be7f24cde08a4f7c7c8eef4cb854c6719e985bc958c56e90f39915ccddcd50c20e2df831d2c510203270eaae8406bc98d193101895fc481d25f704127bb9ba14af92f32e32fc5546e9670f7463824eb9838afcc1d8b949ddd3ad5d2eed9b8c7163c6399e2c8004cb9c67ebc001bcb202e0849d370b89f62f2222eeba6bcee981aafc08674496e76e3cfcfd9f6f3fa608efec854643c182201a280bb974dec04c2115cb7442b48f73dfd6c48fa4876fa9736a44f8be632f3b681063d79e4a212b0a67bedff9956ed24531ca3655732d3782bec8158f6d29044c2d8a30dbb237c6a72dcd8e624f386d5acb3586f5f5ea3368ef130018fa583a7b659c78ab7a9fb372f44da762987257a6436b3e57abaaf8f8e91f74248f0a5abf796fe213e1bd2d05f8ac95cd8298cd3c781468011b2eb5c7fd096c9ee6c470fb7f81dd8b7507e8f5b1c1016a433d564cad55509fb959fe577c112f6d453df1ac22a7fc1dfc94f75b318502264ba851a6bcb70641ce7ee82ae0310b6b5ee9ccd500b7f260486112a2a509beb44de13c388ea7bde5810df498b5447bbdb61cee2cf7bdcd5e6e022d1125d819e6cb4cbadf3c35a1ac331694381df7e1fba3ea6cafaa22f22f5d7252eac0d605f6d0d12f5bfbcd4fbbb86182299c07ef14b7684bb7f76009e07e9e8006dee3f0b9ccfbdcef05fe024d7f62dc254085eb63f401524b94204e2fe407a85179ddbdc33aa452e3979a99178108b1ec1bd3e72f1193e2169bc633f5029e600b8ad8e4bcffec50d41bf1b6eaf8ae4cf40b5a10725f511f213ddbde1824ff2862bf71d17282c757452ec1492f026994a8160899f7df1d37f44578b7b8f4f3f744a8c5f2e1fd0450df00ef0bc9c91281d81ca80a75246852cdf08c49b643f8a3b9f8f397b407fd2e04bd13a2572e05da7115d40000ec6d28ebf4d09c6d081445e21a41190d4010cae0d492e981489d14bd7e71746713595b0926191831215327ef14d32c782b216eebb0e52f91326594d0185ddec0ce3bade242ef2a30db806c72200e04f46b279a6b63fc31347791db4746f2a9ef7591a755c0e79a28b5af566869f12ab09da30c1cc2f8605ce4a93140e8b9bdb769274893b6e888272ff21a10221f4aa0cc539fa6f684aa3579eb736e1ad7a728cf3199f6cc308b538b8fd67a19f909b861455726a98eab0042198293f61e122d286e83d466be64f0368acbe26a8dda813c4fc7fbcb9c76a7a3cb111b249f597ab92d3f92b9ca44c455c1df97ae900ba1c2d365ea72a59c49d50c53a9f6f24ad3e66a71fc468689409ebfb7483b63f379424d763bdf15cb4f2530740fe5f94812e29b985bd403b10b02610adf515b11b84643cb9f447fda4ba0b31fcd1433a7bab3b6224d75b66b593e634214a6c4c501fc82b9ab3f92e77cf267c1f3374ec4cb283d58af501c0f623fca3fccfd6190b391a78f7bec5a475e3845dfd4eac371f7dc9af823460fdc5ec7c933e56f09c697533e38f46f14e2420f31a56753f1546999536e794aac95d87e7a2eaf0fdc401ce740134e0fefabfd1cff5d5622ec1f983edc0c869613357fb623c668844fcb9ae2f7ec4dcfed5ec6cf1779b3f936af325c4341da3be5b9450d815e3cdda68882c4c2520af47402adba61998588a8028e3d4b45b665ed05903cdfe28f66a7368da9035817f02720ea366fb388410265bc8bfbb776e3a102a036dc8a0c4322747293465c0658658e8eb1fcd535fd65a070afc44c7f6fde4925873be5860035d4afd97309bc7acd02aae063104d113e6d0aa89de0d116352c023464a6764d18e746d2b59fc84d76668d4d0a4e7c12ec5b16b495f38981f5a0b2e252a785e2185372cadd105361a81c26c7d12a2e4bc342f3e3b6f9202f1ae07ff8ac94d48dc398c2a7571c434e20bb541e5665fc13d46043fe87a44bc09223874030262b2f02c34840e5961aec782adfa425d0b5ae19e6e59bf291c4c2818328c93770f01d20d9990637a6a2b5dbc0e6fce9d20d0b63bfaedf9526649077efd81e49d31e0404a5c34060408ff32b52745cb24d73018b272e6406110616985d25e45d41aeb7cabcaa829c1131ad0e3469d453407774afe95c7d23caabaf729b55d1ac7bb3004f13c86e6131db11b5431359523e170d9cf71411cc443e8c77e4a3245011566075bcb6f67988c9376c6b47ad55d3078fdd193898ac30fcc1d49ab8da2995e8308adc8f705950813423d556d73df567aadeb00bd9bf7d667d675d63db4f5e3cc3763f2b7c57e69d2d0daac10500d575b880be75a70efde33d04b586a691fdb21d240a53ba8273f0cf772635f5d5b072f4df6874cf18528cfeb5eea911244413b13736ceaf12daed265ce313b940e9a8a486256448b115df8ceb94fbfbde2b9d702c0818510d8f3981fa6adaf91d5d384e6d6db2123c3e7cfa31acc1c4f71050571c789fbed5bcf82ce59c1fe0ba1937987fbac9ec6b336e7ad594d75125f330b2e879079f07c232626e11092d4a95481fbd2826dc569ad81707a595840a1de899d52e4b1a9f9a41f13a3737378d8e01c28b45520f66d0ef2dd82bbbffba0a52ade7038d40c4c9e6f94bc532619aafadd5c2d42d0f8639be3260e0114c4f1525e1cb33ce06504c9372a4b7f3369aa521b57b5e0abd14b1992005b42540ff35f86bbc1c4b00b6f35a30f2cc3a01efba3b8d70f4736c114943fd8de789ee027363f95ce4e5d8211a19d5a0201f0d322c5a35006e6a09b7232ffd3cff5329f43ab41cf679a0eb7369abe350e8476de630c2934310d6e0962f7c7a97a328ac2ea33878b59f51fc38c99c85df6ed6d6639da14992f00b563f13f83a3c23ebaa825afe7b3e2133cd5859f2b2dd788c50ffaad9565d6647a0a49275d026bcedc803ed31597286061422ea9f59911a7cecaf14318dd86da42ad2744c23cb5b6ef29372c2ef29e8d0c2c70f91764320c1874d894e4e37050d5bbb514d31c870560145e415e874b4690d20eaaf6c6287360cfd511de8878367324455290973ba338a82201bb39b8f7db88a9631dfd8495d9fdae9d46bea5ba2e7150b8b645a77fd683cf1adda8d87c8142fe0e10c98967f0960ea8705263a400e5cf9a70ee8a35936d25319fad3b6b600323d6946afb3c43856cc07654e1cf53b354c1c1f4f37387728a01d2c264c90060de5ad5a82dc5202605d6d36a41df879195e45a32c346e2904cfe38f590a270f374294da049265a7c5969b7caedb45c429e790cbd7f3eaab07e634eec7b6eb9ed1d58b6e584140f89b3641fad86a69c7344f3360c07e84a662b59dabbb4bb03dd4dbea4ba8c70ab9b44d810de2ad28810e763e2e65c2341b37f6c6f9c22d9e4ea65ddd28703f8510ce7ea791159dad79bda68402c85064f57472eff9292dfc83b2a04df5240657e741521e58687f276bb9c96b042650a4ef45d5f74f4718768507964d31439187fee774ad099db6b9ac94a722c01a80d61b9eca79945f44be16558203c04120e893bcfd47c7edad1a82a6063eeeff8c22cc1573f304de19d28ac93fc3f317572a9cec6921459be71fefe28924b877c5ffabc89a4e516c7ccd5f15c262f9ef0ff2c046f29428e8208e46cdb00bfbf270ac582a8e45e6f79fa6ba9018174afa36657f30bfd7f1b48304497fe0ee5f24a7a665558b4007666d5b22833fea8511ea64125de8e13d75ec7e5f96898c99ea914351af39f0505e77cfebc70d176373b8bb39aab89c3316015fe8ea31ed62226bd24c8352104b22472f4447d1f28dd654ec85fbd546644a09358d9278066f61b3ee20e1ea3071f63166c7b9b0e6cea14434e1032bb08971a0f4e9de1807858a96d8d4349a2f52140ee82f20d51ab19008c696f532a748707fabe9f01fa4d1113cf18e1f76ca946a65389f05cfcdf1a7da86dbd82d2e044a3b0227d3c2ee92a7f2eaab86c587f7e873d87a42caa9d2ce8a36727ec49907536d356ca72d2339c14aa18dceb3ba55cc90ee15d16c11a89523b3a61c481ba66230ea3dc9b6381dda7266a1f48e38a5d47e1a81dadce93643aae81d606af82d7d654d24e52d725b116e239cbb3792310a2efed5a39d5f35e7c1a2f31cba09c80e018570608db37feabeedcdbd44583f64bc81a0a6a665bc8ff19703812bc4daaf9ffc76308c067c934200df212f604d1abd87215e32aa36d2b1a282d733a93a5451e36c435b214800bded770c8cbb8307fc7748eef8e3e0336775922997285b57df76139516ef88069df3b8e3377d3e87f8dc2baccfa6b07d6bea519ce34f854001aa2eb65a3350f26439c33f3f3f3f3f3f3fbf1cb1b7d4d516c6262d2529c92c211e539646a09b524a52a694ac1a1d2df0f9057805dade4facbd054a059a05a7f6e7d0470d613dbce4f474642c74c8a1fddd5431e46cb942471c3ae0d08b9814a36fd6a8d0f186e67297104144cd0d6d9ae813498b0aedcb2ed0d1865e7cf52c47d02922e860432792ac8b89e8d396d0b1864e2565d1720a1682b61c33521a4ae85043fb6b1524887213bd2d0e1bd691863662484254928b19290de342071a3a697d665aa35b57cecfd089e8e98ce80a9b4dc70cbd4f724f51bd4bc99832f4577a2d1bee39e6207790a18ddd5f2a5ad492848e3174124f78f8cc9c73865f0c5d8c18e3e9926bae550a439b235ba492adc1920adec0cb281e28c30368780e0fb818687808f0d0f01c63b4a0030c7df8083a32b37743e8f842ab396350256ecab4a75ee82b8720248818fba5b72e749a44d098442efc4cc485b6f2a8ea4b1227e6ef3ab6501d5a30e3cb1883041d59c0c2151ed061852a6c071518d03105087448210a507882139a208618e60415e860028e2544a043090de848021212d071042328a0a3085e7410a1d9177d3965bee9bfb4e34fcda91ef21abad12184ae2ba770611192c4a03d33de13010b6c0840101d41e8ace2a81c4cc5b03f3177e80042eb19d7affde15d4f5643c70ffad19db4069d275216f93b7cd0698deb21acff070f292ee8e8c1b16dddbe59cf720c1a250c1d3ce8926fd268bd672215428d5df46619d1524a31725e6470981b0a831abae8e3c397a97aa9968ae7a2554b6164ae79d4991c5c74d539a41c6a124312ff2dba160dba4ae68b9bcdb7459bef9e2977c8b1b3e46b91cb7fc62cd13d2d7ad9f152e27a3e75eab3e8342751da1fafba429745275b63e78d41b3c4e5b1e83cc61c82963e9dc2e5b0e834c8f073157f451b24fba6b8e66bca3baee855be948c19428e586a4523621251aa9299262db3a29d97cb5eef90b7c2abe84b54240f9fb7787555d1f5bee909229ae5896b2abaec1eb4856fc77e8f8adee3ba47824cb93dce53b4bb31effb7fe820715374d5253c7578878d9352b4a94369e7efd133ad90c272d418452733430afbe1fc54cca85b410d5134a79962679e76ca9d84a2f794c9ac839680a2ada427a7d8e191c4857ca2cfb0a2a3268b9a99e389b65d83ca6b61ec44af1d540c42972e61227262135dd02939cf78ae68a9d3447b912a8975f98eaac94413532a71a2b9e1f48b897e633ccfca917323699768a4a9d813da549c5f2d812775f5f2d3150ecc0c6cd80c0c5a096a54a2cb091a792689129d8e90e36988a839873c892666343f95d9bb337924d1e8c9d0cb5799c9a348741554620c6a614ee4940a6a40a20d323c5ece9f7c44133633279fe6afe698237a570f79a95594cedd36a2cda5f4e4ba5ef2ffff86da8a5183114d523a069da2e93f11c92dc2c0a8a1885ec7f4e26605a1c409dd50bbab418d44f4da25643687e3665003115dc8304fcf24df99b23b449f518394134233559f0cd18c5241b4870f2a4423cad2d2b4e886a2a08c119c211963700c6a10a2d1fa1e2787909b39f78368b6e2adcc2d8494521644db9fad73ac8a57fc6c20fa60a992e41fe9e1660923b98de468989103073901b0a1062078b10a934bc95db5645a269554035f428d3fb4a74366caf034114ec70ffd28edabc95248161b6598b152a8d1873ee5ef070da3c487be436750a67b3277c820c303790278448d3d7462e1f457f8e986a57a683e28cd14274e720c2d1235f2d07612b54c662ae385150fbde44bcbf12af67612d6b8431f433015cf63b49e6cedd024f19dfc2ac43899d13a3432efa32a785e134ba941874688df0a416759c88a23a1c61c6ac8a1b9ec16e45c570c614735e2d0ec958e217bf8dfd1308c2f6a045f84f14589e08b30bea8107c11c61705822fc2f8a23ef0050940f045591e6ac0a1cb0e7272598be7c5c9196abca19d68669935a52c4287d60d6d8ef973f252c934c5dc36f45da283f4093989ca911b6a6c68468b88a82a92f48c871335d6d0e9ea0fb23fc6383a2c374cc7a8a186f67af43748ed1c396968d3f2c286a61426244d51030ded7e921073789fd4294351d438431f2c478b9d92181d8d334eb3103c0be38b6a0e6f77b66aaa978f90071cfa98376daa83d62f11f2784397b462cdd747af97c8c30d9dd49341c39255f020f268437359737c99cca0ff431e6ce837898fbb2e2149f190c71afaddec7a3272e9681af250437f223b07b39c3dce421e696835b6e7e092248a698f071a3a8d537abf37cca994e3718646c7a91836bfe3618636e7334ed52756d01d8f32f43904a51f4ec71cfe371e6468e44b0839564eb941c8788ca111fa655f640af954c77888c1ddf029e8a0a50943a349fe675e2fddeac1d0265321d12afe854e9e9811264fec8546b3a89cf4383131e52eb41f62089a93d8ae1432175a4d9129867c19346cbc85fe540cdde1748453166ba14ba65fa4fea959e8635cea4a8ed164ec2c16da1c4425b8c6174b79afd0b8a5fc51fa218791ae15da13e22b5a0e316c26b70a9d9b868bb21c157a7135f7904f3eef53684546b448a6f52c2885562564d3544ac5e46aa3d05ac75c6a7a3ecef8506835c498e4c58dab9af4843ecfc70415adaaaf7542af2132448814645b449bd0f99a484a86299527c384fe3b2f7950f273424b6884461e5329f39e5525b4a9c3494a5274ae48494293e4c73189972da721a13dd524be3344c6acf2086d4fd261257c4ad2b811da24cb84c5b83fa32c423b71c33cc7d614744c842ef9a549fd889b9464086dd28d792d9b08ca3f21f41576cf62e508fdab04a1b7d471c473ec14c404845e9212a544758a18c43fe8d23a93479e994f7dd0eba90aba82e90821da83de3c7932e95b39fdf4e041d7bba135645f8ff7c82ed0c1fb842af151176d7608d19947988b4eb6b2e9ae6ff411212e5acd382254ee256f0fdea28b8fa83127e31d46b44573122eba08f7f9f8612d9a4d227f8ef93aebfc478b7e5692d44896df6273b3e83c82eea05496452343c60a274e2b7b1a8b4667fc1731e1e3cf77b068b6c473859cf287d32bdabc7299d25d4e5557b4125230d3a8bff9925ad12425f348cdccb8f8b2a22f29ca4d4efef55f456f3af3261e4cbc4855d1a6521ae26e281d95a4a2f74acf319f5e57cf50d16b086147a66e8bc9b253f4c13a53ecec7f4a3745af22cb5cd46256a614fdbe9e8955c852da92a2af7ccfbc5a5a524747d19c5e0ed35e39648788a2091e54949c2995f02c146d8a62d1d32da55f551da068e22575c9417e271709777ca20fc1db4f5ad81c5f7f4ff431c6a4d26e2f259ee9e8442f4254dcfc227b4ae8e0447fb9133dc53dbd414336d1c9181a4d52ba85f5b9860e4d34219ce88a63ca4ac84b65a2cf7e7995223abc982925b32be8c044ef3f31662bedfccdfc125d4b88bd1b263985382a5de8b0449f43de929b636ade14a9ab44a7848a9c2fdeefbfa73b073c9027880e4a743146710b31848d19a649349b299f2f6fe9cb7f7648a2c921ea87c4682264f603d11189e6f4ef87102fa487d93c5e192340c1084e00021c94437440a28d12563d77043bf08846e609995cf42a6a49062607c14087237a0ba72fa2f9a9a3116d2c69d6a6e24a85f919d1791cedf8793a2815fd4534a694c8213de88ae874e712e1b12f494252229afc9377f4c226155308119dee4af2eab718227f8826e6a422677e45c8dd10cd7b688df551e15a54883e9a0cea5931c7fc23215aef50497716d3a9536710bd7558d3edfefd2612447f3a9e2f4f682b19e540f461e3fb9498246f420b88be4bc47895a1e34b5efed0e835cdb1a52274c77ee87c82bee07941845d491fdaf816a2e47c6e4cbaf1a1bdd2efd110d61e9a8f2b5bd93e12b4dfa187feb3bebf9b4c39963779684d43c5ddd91e0fa87b5ac77cb9577649591ef48f328b94ba927b1d7768b53595a704d1b92de5cecc46191c3aecd06e88b1cef162c5b0671a3aead0bb889af411f20db52fc20863d10c1d7468c3c6a44ab5bf01886696928bb39062c806143ec2d0eaee5c4c512b33a75eccf8004357d99a530a612e31047d7ca115cd8a2e22267d11c61722b81186177ad1db1ece532fae68d048c37c74a1d3396e8e9d4d9c96e754f8e0426b59a2e8a09654f0a4512d7c6ca1c9999bbe9a42b622270b1f5a683c465f119263c9b490287c64a193642e33a63b86d9d10a1f5868b3476a0757eb4f95b8e1e30a5d38cd96725b0e39ea69c3cc0e1f56e84cf2bb84c91e5f3968c392101f55e843466fcc194fd16f5a457c50a1d37e5322f5281f913453682b85e5a410d73f590abd0915993c3e3f59bb5168f4f5f248f0ec3cca0f28f42b7bf9842ea53393f0865ada0d1a0c305845c0021b39f87842a33a72e4792d9193b91b6a3870e032b081c698c149e30c1b363068ace0c3096edef6bc8ef91c66cd3c0d1a9833ccc8fe6842639639a45f0961eea1c10713fa9eeb7c425ace828f2574c15282e89a08daf4f8a184dfb487143c849649c4f84802b9230695992231dc1b8a820f2424c49c48c9347ec4031f4768cd254e2c9139e8b2dc085d7475b19865bee4344540e82c3a8693ffe80b3e88d05a8a982c655ac77fcb101a954d2cb28f84d0a68fd29f3467828c5c105a8d5b9ee43452c9cb3e80d086b3d8217c88eff0f1833e55923949f85c4e9194810f1fb4f92ac4e81e634adea38f1e34922cc7082a5bcc7e8ba6870f1ef415fa3de6e19f4a625df0d845ab2dae56314d73e276c30666dcb0810d1b781989010f5df42a3aa9649d54f6e8701c3c72d148b34849ec4890222137d4d07294e1080d278196073c70d1e64e57f9d548f283521a67308e6b8f5b34a37284efeeb9b434c7f0b0459fc54abbc5c92999b35af441c7cfaf68eeb8a81c471aea418b2e4334ebe8412dc41e719ce1f098451b41c8683a252e8b56734692c14a55d0a3c7a2dd904f277d512c0579595834fa2c530a7a5410f2d157f46a1abf4a73b3d2e38ace34ee45908bb825b356743206919147e6b88e8ecdf06045a39fc2f6898b1fb74a83c72ada93158ff8b174fecadc50c3011a3954d1295d4a6424ee5766eb869a8d1c2e06dae5f04845aba9536c5032cacb2a54b426deafb1824e229f9ea249d23447d792b39de3bd828729fa1f3f8d7891c5428c6e291a91adbe987f2c4636a468c4da743b8cc84b31d951b4712e4fbc049545e68d133c44d1a94aab1c1f5ae38e960a1ea168c22615b4c68d25fb632dc103149dc5a748725a36ac348e82c727dab778112bfca7b8608201461b3c3cd1a6ab7e4c4b3a9a8a5651824727ba2c1ff5b8d22952e6337870a2d5109f2cb6aca44aae95c163135a94a483c7d89c6436cc48e6a189563ec88f5f8ebc102459f0c844adee126624654f931f553b9966d1da302315d3810726fad5eb8d6d226c0ef9d8b09483c7257aff144298cb7183a9980e7858a2cfe1418292e173881b6266c3cef2e05189f6cba4f8a9fc0effa307251a9943c5b21c279f89d8081e93682fa498c89bf96f569144e77142dc54a27d5cb448341a417ec4450f39254d1a1e90e83aaf8ad2be3d49c6240e143cc1e311bdea4449e121623c8737304303608091fc06ea030f4734f39742e6304931898e4723baa09719363d9f4ff478c00362b808c0000307103c18d126212a83dc5e39fd17d19f282136468cffdf15d15ee9160f131a329e12d1464b1ecee42f7e1221a28bb14728135a44673e44af974b4fc920ae44d8106dc7105ecc3fb7f42d44abeedb9a1a25441f77fe623e731f490ea29331ba8584357f9d08a2d3612be7673f693a12882e335caa90645c34e103a2d3ec31ef94de67daffa1932a3a265379f74397a4a5965f5e28a97b1f7a91b11c7e4de7436b799ae299580d3ff13db4b929881c46c29f97f4d07c18b9e1a2e8dfefe4a1932d21d43c732525838736f228d329c5dca1ebec222f31949cde0ead684e426472b7c85c87fe4b73f5c4923ce8d0e4914fcda2db962bc9630ecdce76085173a7dc3079c8a1d1ef2e4af64c435cc9230e5d0114206601330bdcd545600211c0c10c72dc10638c322c50606882611228400070702ce0050072e048c3040408808b61d210a30c33831a02c0818677a0c002c90108d8008e31ce305e04a00900c081e380410001981c2681518000981c26998106180700c00016d061c6193664804c0e1c366c2000000150c001708c1c68dcc031031b363abca0c201bc9842235458393dfe32baf10db533c84052e82368d1b810b141874814daa4f4a3e62ff1577a27c3c9d0f4020a9d2c93e0fd61826ed4dc504b329c8ce2c513ce2003392187e368028e91a30663a4346cd8e8f082099d59879738d3f7a0c23774cfd23823c3d1b0518331928de4c8cfc0c196a38c3110471963e44043bd5802dab051c30b25e0e00c44869361002f928063e498c10d1cc6868d0e2f90d0572e0f16a223e4cbd011ba12a3c9524fd6dc8b3142bb9364dc3099c4c6ac16a1cf94645b3b9c4ea65288d06b74b32c42cce84ab1213426524efa47a882e085107af7116bb95e1d3db95b861741687c2b525947bf98e309087d0a9b51739ffca9387bf1834e2ca7de372fa5a325f920e52b5619233d68c72bbf7ae5cd298a5ef0a011325674887abad2c4bbe83b04b51832a80a1d72bae8f3e777f6a07f46853e17687a65676c6ca4ae94d20f5cf4494a88294c44ae7bf6169d86368def7ba6e79e2dba1035b5f379e5f194548bd6e34b46ae3ca9f0950420f882169dae48d408223f8b2e89688b57964cc3872c3a4fc93256b27c12668f459fabc3e362a4c966132c1ab3a0e5ba43453c875ed1e5d131f7fc22676ac715ed69c5d091a145c3ccad68a2c587501d2fcf8895159d6cc5bce4acaca293ffcbedd20aa144a88a46e54db9c56813b24f451bf4098f9e9be1f13a5434de6e1551e7f3ca7f8a3ef3566c659c4a0b3253b4912f3cc6933313d62a451344b5e8b2582a312f3cf82045a7443b898fa4646faa46d1fcce876c2e4aa9f8bd28faf45c99222a8ebe66a1683cbac47c49ce2765da1b6a34701af40ccc1839d0302400038c33c840a068c48252cf398d7325e28f4ff492ff63c42fe78c8e7ba2b5786ded2fb93c979de8248cb2bc1e45df535f2e051f9ce874b49c4bffe2e70ba24d341b7f7243c8ad1957d7441b54d690542b5f0caac4716184810609ca30830c32cc400445c0021b0320c247261a11e39f93f808135d7f8897e35ea5740f5fa2f30f8b599208b22a9a2cd1a8e658aaf2ef25a1bc4a343ff1e39b0ee2bcfcf4c5094090f64189c652576bce8f30aae439888f49b495a3e44a2a32479492f88844fb2db93a4aeea4f28820d1c420cd738b89560d3d79c3c7231a71b9f430964b5b7b1cd1b55a789094346b44632262659a12e1c207233a1361a6c527b8aca77011594ef18ccb4a2916533e23a9a4e742c7320ff5865a1a386c20193e14d1a756f64cda52c9917841f491883ea50a3defb093e003117d4af92f673e6685e038dec1c7219a4f2259abf8ce5536cc4865041f86e83285d32b9ff15c4e588876437f107e292dc7ac3ae183109dbca81e3c33baac8cf2091f83e863664ecfe19a7d73268856a49fac0ed24c24956366c3900f1f81e8829ebe5a5b92b32502a2939f42e452ad29f4fcf1874e98d66d9f8bf0f9b33870e01ff8f0431f2a4ce60d71fae5437af0d1874e5ba949f70bda13f489f6c18736c34550b99bf2b508eda1d7b8eb3151d543571a9310f1d6c9032956fba85c7283872efe661129fac85115dea14b22aec7f8b95655ecc30e6da7ee3ee12975e85c9210131a3f6ea9121dda20fabd8308f1c133e6630e9db83c21257db51c44f6430e7d924148ef7c1574c810c4f111872e4af8cfe4172ee5087ec0a19c154543dbe333dc4d557e0ed92cfd78432f3b3925a574ca9513bcc2871b1a579dd4471bba1e0d5945fb9e4e0fcac3071b7a33a9325963690e9971401bf1b1864e98f524a1af625f303fd4d06bc813295c5677723d101f69e8a2568ac994faeafc8654e1030d6d96a4594f559f52da245ef8384317c4b598a48a9343c86ee1c30c5d1242a77832c20429f132f4f99b74eb24d3aaa22243173d37fa6995bf7a50093ec6c09c4975cf93611643078636a833685190821806621084411804877d920ed31348202030228c448231a948d7fb621340c1c9420151280c8c850181300aa31808422088611808611804611008846006917a6bc9da9292c6325469207168c42c4713ccdf60c13c0b1ba2caec38697ef8f005fd673958deeb053c307b3e75208717bb45384a670489d096487b2e21442bb6a2133faaea6e8f48d8c6d77b2a24e1e30e765a5c4ac2b6fa3b12a349fb86952c568de4f5498d45fd42c9425f42876b9461567d24b06bc9675c8f60fb7b1ad67b8c02ca2730b08c03211c5a7f660e13e9b2fce4c089fa668e0434072540d5812498ca5a03f576a1c041cda1e2a11ad3dd2ad8817e4cb9e9f7850f5def1b360aa60c7196f1f07da455bd20cbe780a478357f8fda38462d4e21da656374743b591cb44c23edca40b3c4c3aeb190569564e4f0c11c07870679e0cdea9501394886f6b079ff79e779ae798bafef33f4ad28caee99e573158cff971b88d1e34fefb0392f13bd68e4b7925212f8748c486ee36d681144ccf95e4b022e5092c168cee80100563cc8a74f346c724ce6a925f1636fecea651f7080be4ed8f186f353422d23a4845ffa10e835b3482e8a8b7a3a129c5f97e2c30e18c300af7d0a3159db7112d6c22134e40bf4f4fb25253a06147ef22a379676a29101d993219e97cc7cad51c91d988d7c2bc6cac3cc735c46ab9c51b037c28a13898f86a6001a7a535181a5c0bdd666c1fae36c745f613804d42eb6b2fbb31cf63b449b1aaa930a0cb1872d3afc827b2d3a5ea377eeb36d9b7a6317e8ccca11b98e456728073ce8060ccdbbd900927888d116ec3290e5c9a9ea08c269db06b9ce3553b30505f385825a3b5fef350f99785e73800f1df8ffd0ffce82447f55279756335a9a651334cb6a105e1a640f1c759ccafd3fdd8102403afc3ea1a0caf0dd17475510ba796eab22c9012896959e1f813bcc03571f079c62d2026b2b86601848265007ff0434bfc7c3cfbb24a61faca45415076f7066b98bf9ace1f00f2de3166f7d856df77d1b03c9ba1db2a2dbe5688decacb492ab0ed1c5579e8820719b508ec1cd4731040c3bd0b0aa696a1c3f29a60d07e468c59c38235cd7c9432094b1dfc89ef1921b8c5cc20c6ce6101ad590d87e727b9fdc1214c130c1252483c4360455b395e028b96dcb7468b25c786dd76ff254b7acd46486a216ac9e18ca830673e7985b06f673b0face5201597669b28b1134878239656218fe1cbb8d8790e66f30049d2e378f42c770f1ac8989a3ca6dcde62c3cdea872f8568388b4c92db78ef92d18909381eb391884bd7db128fa6b872427fc2c194b2ba985bfda52f4e641eaf0d5e47e360472117e57337a7024f1c5272a027d0a7999c18bc1b8e6b1a5f0538d642b1a51818328a7ee406bd70fe84df21c97d8353b2c4460fd29953cc7ed442878b9e6259ae3e2d84f6e9357131961165dcae30527a2c737f425398678c88c30835094f48f0315dead2d2fc4f72960f22f1539405176114a078625f3f9a16aa9100c83d53fcd85bda46bc22965ee8cc7ddc559c7743582d389a625b6328a73a3293f65b9cb0d546c0b8650509dbaa4e72f0ba594b8df2abcad1703c01d4999c9e117b005b70af7acca4c72a7217dc1a490de0dd7aefc8d8d6e4056c11e0a4828c80b745734c34df64541313d2b440483d2dbb0e08e8324ee646fcdb86841f39026387574ca4028e88808430632893b34d44fab4e656849fb43bec73f744cc24241b01c9d814751ccfe11a762b5e5e8b1e0af0524f44a08bd3d165946169b835d65d18dde27e620610520854452b55a8645e0839e4101c66c43cf79f1795a49dc20118f65209e74a4b524a90c7a3a6ea8610b8687c2bcbd0a8f21742fb5f5847105fc86c531c50e864924e1ae15f36b184880390eee86ac25fa701b2c999a2fc0a4aa84480fb257366435569a3dd00a3f2ba496cc00fa3f1ff087f8359ccb537aa63a4bf10ce940da990ca87fdc73b031e426a2d9db781c9c15150a2c91af25c43721602f4dd40e439ed40fb5f2a48cae4e541a7df90af15f6c72ad67ce5b63bd2850d3687919088f9ddc0428c30553914ec93d1061eb6ffb32472ae43d0a6c4ea28a8691b39b953a23066650ca108e6d4d12a516c448d4f09f8cf9fb074b94cf8d1a4740b3f86db6bfec92eb2e033b3fb0433169ca3d8e477dba82d3e88ec5b0390972d43b96da6c60e761835234975233889c5f96dd22d2b4adf44f35f80d83dbbaad4df9eab2217bb57bff2b96305db11718eac4fcc8ba6b233ce4b0ab52688f9234d00be1b7dfa4796b099c1013cdf13b3dbfbb19b08a8607c9fa569138eb4056a2fc7ae37dea510053eb2595a475416516260566979a372919801863a9ec1d0a424a43154009006dcb0c3a76c5e0470e5065912925520116bf6091d34931e455fb19d3272407f7264261b454478be180a985ea4b7c96ef28ca73e66e96c48487c098b8d4c34fc081b97f72e4dd0a218635187c30f78b269d830a9e1c0f078468d2060cc0411a294fd9fe47cce0bf4dcc4f7b85be4311359340c310711b5350718edd0207f5ed8cee5f64827b2d85989269f800581fc1c5ab9482f67272b3dfcb886b4580225ee5acf00263f824c09d74ca150069e2d2e74c9eadaf68bffe23e401bb91c8f5fe7968bac85cfd61d6e40bda3826fc45b7e99206e8ed301519e64d63353c9530c9bbcdb6b74f8ee3dc81dd8bb68fe682a26cdb90d2f9dfe54301a409615166bfbf64349c81d5603c19ff45a7a5b68285f11d38961a9a33139601954a1bcda0674689790a6c7845ca280b17d917f400b618bd1fe941178b6facbf472c3b3ae0266b1870892496db6a13f5bc60a937325b3faf524ce50bdcb6d68146a0f419086e6695d8d307f1ab724a4b42e9d155b275b848904c74c264e05e40781ca6b208c314086e6fd2c490cde9b3acf13d6756772c0d75e8465eae8349993229909982c885d6ad670c2ae6ec85b610ad8eed4ea4977a5cd40165cd1dc10904e794cda789e6ba65269149e856a16dfd97a5fd1cc5e7118b9a5f31fdac2d068a9eefe8f398b7c3ab007ff2fde0f5d7bd6bdba473000a36cf7e541c5b857c5b5590cda90e75be8296a7c0ad67bbd41d87efdef63dcb798c00f3b98213d00dcefb353ac114c35859b4facac5289c012603a8c28414e86c377fa1615d4751112a00484a6705847096b0651e78282e2150730c0175c323240b1d227701b966f0bbd30c2d464fee4bd70e716216387dce07a71613d02862da8fa7f62128e56b0402c02c79e3f1427b57cdd1692279e728344602ec0113e123f55d693650d01be2fcc13f8e43e833ee9b3aacd93b0c1a2ad96d0c205003598c1a2caebb534b12b2cdd7012cb1c748a22ee50d7e6c1f112ef681fb8a406b2d8aefb2a7c3fdd83e1cc646ec43116cb0fde92b411c99f5541b201ba4b6f0bf576f5c1ad6e3cc54dbdab1d3064cc1089367f09e3dc334bbe66974cdd3e89aa6c9354c836b9886ae958608a23ace816199301363428fccc6f71aaf4dd94ebfb672d0cc1282e309932f9444b8a8a625b3f6b0029df44c43522411e44b5e61a5799032e3381b265e185ceacb66895706963ab37d092eaba5af6c5b82ccfad2be0c96a6b2beb42d834c7dd9aac45266819c85ec65d187122c5a42a5949550092b51a5604d052474a22ec1f130a59439a69d381c6bc3777270791f9be59c1a60ded9f6e570adaf7ca6ec38167b39090134c881ea5b900d4af3a58c7de48d0d604085787c1018dfaac40adf18a94f8a5e944e82a08ea7cf5c1ce52d86cfb37347e66667f87cedb18d6188671285a6c961721104feb7969ed215108611f50844a4752a211ce533ff630a07fe6421601bd78e4e6d4e7cd822332a7442eb6ef709c6d09edc22f094212ff8a1a978420448f72cac0641e2b69ed456bc42aff008e18742c93215a5bab9cd22372ff89104dc248d46dd619da457e0b0ba491c8463d866384217a02282063999bd35464302ef02876b117ce49180e958c881c5841083719553805602a823fd82dcdbb1c5f5c3fee672b7a25f1a0daf8a8b1a0122a12acc229aef5de024f0f23b79d20d30f126f500c8a4ed4b8c296bfefe607c561832f22067bf1a518092b1dc33321f363d8ac9c7e0981bcd5ec3899fef10a3cb7e8d57ae481ade19e323410554defb534e832e0b5472a545ebedf11b69282ad90c74d935ed8e41df2c53562f980bf9238dc4543c7ec1da42518a0c1b22b0e8ccca1c468a481e497ee153ba8c0bc9016b09a5fedd38f17c1ffc90c9af0ef51476e8d72ceeccb44097a998a5743ec754e09c52ed5c4af551e50e9487da639f557682dc91af5ca8580c8ae97172c4407dca70b0ccd6edad546d434667e2ad7f3c08a036f004e787d4e31fe8a23142b80a03fa396c38ebc3e565121e0ea97c9a21886541c5a3cbd065e16e67491456a14fbee0eccf45fa6937aea47e85b2aa7e3aeb00397a1dd161ff15ce539b443ed1b996abeb26fbc2d2b58d2b94bc059809945c764b425030e646e3514c9bb8648d01513711c446bc2b3a3aa031bff2baf23d001ca2a81863da528c0f6768b607c9b0bebc388c89ab51c9da512dac51e54e20a8d4234f7b7c0f12f6d0fdb675180cd029ec7e4ae17581e515d29f96db019e0bc96913524c842e4de0cb0a9cbd3e039032568a73468a02cd1f8cc9ee2f08623a49a14f362b76b4cf77eaa4ac783734482639ff2fd2be5ed3dab42c02c03b305245de76b182f0575f6018c58d09255b6dd8355a54d456d1136e08f180f412156b3e0868935e9ce6674da9b83b6e542aeebaab545c0aa6e2b5b6b05271f7d23b59acd35f33bc136b65a2810fbedc1eef1477cfa0a5e22e4ad8527137322e157735dfa5e2ae89f2527137faa5e2de045ea6cd9e7349c798031c868ec8a56f04b58c4d52dd571f51540430795202a8582fcc408817170f7797a9b889c169ff5d6e00343924c6dd0a5543082dc10a13bbbe82619f80561c7fa708bce86538f583fe241f008dc17490f2282a7b4b6614ab088031344c4bfb606a228ee64290b02ebdc65e62c1924828664bf68f60c6077660ac4d871eaf1abc7eab1d5011482c1b98b441316bad10a0ad18c37184741c0d476b91a60032d995287c30fc346d94a95cb2baea91f501e804b84a23ff3188e4da91ad3e42b661d8b4ebb83f00ea6fc5788113737189bb65e4c702adbaac00abd7bc229f27dad12c0c5601a61c67449a89c84583300c24248257e19ec04f05a9b9c8da95e1acf1923861f13febe13eca7720dc7e4c00851e0640451ed3e73188f8afee501be0dae1b84a58525b3846c7bc0de9222549d8e234544698b8fa84e0351d16548eeeff80c0509ab527e757f5849586a4aed2f69dec178ac507fd563ab40d3c8f040940a13e610e57c5c3e2eedd73b8b3068aa4741651a308bc05178ea404cef04c0d981c2c0e7adc394ecce858cbe4a8e4caef0624add72c21f70d6b7f195a8f6f4326a2afef49b2b222e977760baf4c33324805bc4b8a1f108153a6434bfe9d4ff3a90ed15bca06957f7ecf98a51bef23a4d24dbb139b5c60f54a1216126e5f00eea6406d0b0ce9a4d1e4691b38703c3b209cc7f5c9d3ef6cb79b64576729f832eb3f5e109e2833f5c49741ffe9c034b40c1b123c3f6ed673be0d6bf00f06ba2783068a00d8decc3f8e4afeafb75b6980713351f17ecf948fbae083bbe0e3863ac777814a89910e6d1ce063595ef8e0ccf3109a5c0570f37f6cb1d073e93ac96baf62ac170cba1564ef2352622fdfa92c784428ddb6ee58db3f82834e716d97723ce485eda31c17110cfe6afc437d33f435a2e5d6e34f56e0dc74295be8f8758d977004b697205c5136fc1155cb108d5f269d778d851e14847cb37b09696991c56bcb11484825f322c6d1afd20a2e9eb4ca8c661533c3c68e8a19134254d37f7b44ee68a41dbee867f32af7172d3968afe859d85db330f2ae55d071aa8b034d518d42705a610aa926764cfa1e2b4644d558510f8857207011a356183c181f1cbe73525904f6c30373115083f2802c1ef504941fd295fe825c6b200bda4f95a9ddf3ebc777634af8a1b9c02ecb6945e63fc8d2fb210b6925858f8a4b803813c473d1098f486eb08b1e8ccfafd351ed45e7224d8d79053d9585cfd38a7f9fabebf5a92cc64d47e5a63f42b9dab6180218db10b24b47b08c7a488c3df0aa16ba16eb79c878a4f4362319243df5557353fa31b9dd3be9a2fc40625d1bb2ec01", "0x3a65787472696e7369635f696e646578": "0x00000000", "0x3a6772616e6470615f617574686f726974696573": "0x0108419c48625508cc74c8c125dd0132158d3583b479975e516c3c2cc1457d11a7c50100000000000000b553650f5032ecadba5df3bd35e8d280bc6f5cdff1beda8c504d6cfecc89c63a0100000000000000", "0x3f1467a096bcd71a5b6a0c8155e20810308ce9615de0775a82f8a94dc3d285a1": "0x01", @@ -43,7 +43,7 @@ "0xa31f5a5260e78d7df27950c13d40704c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", "0xbd2a529379475088d3e29a918cd478724e7b9012096b41c4eb3aaf947f6ea429": "0x0000", "0xc2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", - "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x00000000000000100000000000000000", + "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x0000c16ff28623000000000000000000", "0xc2b6ac49ee131be4de5527a2ccab4a674e7b9012096b41c4eb3aaf947f6ea429": "0x0000", "0xcc98f986f653d94b4d47ed05aa4522194e7b9012096b41c4eb3aaf947f6ea429": "0x0000", "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332100f527e678449dd0f100000000000000": "0xf100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", diff --git a/node/src/chain_spec.rs b/node/src/chain_spec.rs index a428f7f..7844999 100644 --- a/node/src/chain_spec.rs +++ b/node/src/chain_spec.rs @@ -1,7 +1,4 @@ -use xsocial_runtime::{ - AccountId, AuraConfig, BalancesConfig, GenesisConfig, GrandpaConfig, Signature, SudoConfig, - SystemConfig, WASM_BINARY, -}; +use xsocial_runtime::{AccountId, AuraConfig, BalancesConfig, GenesisConfig, GrandpaConfig, Signature, SudoConfig, SystemConfig, UNIT, WASM_BINARY}; use sc_service::ChainType; use sc_chain_spec::Properties; use sc_telemetry::TelemetryEndpoints; @@ -14,7 +11,7 @@ use sp_core::crypto::UncheckedInto; // The URL for the telemetry server. const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/"; -const DEFAULT_PROTOCOL_ID: &str = "subx"; +const DEFAULT_PROTOCOL_ID: &str = "sub-xsocial-v0"; /// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type. pub type ChainSpec = sc_service::GenericChainSpec; @@ -195,7 +192,7 @@ fn testnet_genesis( }, balances: BalancesConfig { // Configure endowed accounts with initial balance of 1 << 60. - balances: endowed_accounts.iter().cloned().map(|k| (k, 1 << 60)).collect(), + balances: endowed_accounts.iter().cloned().map(|k| (k, 1_000_000 * UNIT)).collect(), }, aura: AuraConfig { authorities: initial_authorities.iter().map(|x| (x.0.clone())).collect(), diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 9354c43..b02de23 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -39,6 +39,7 @@ pub use frame_support::{ }, StorageValue, }; +use frame_support::weights::ConstantMultiplier; pub use frame_system::Call as SystemCall; pub use pallet_balances::Call as BalancesCall; pub use pallet_timestamp::Call as TimestampCall; @@ -90,6 +91,21 @@ pub mod opaque { } } +mod currency { + use super::Balance; + + // Unit = the base number of indivisible units for balances + pub const UNIT: Balance = 10_000_000_000; + pub const MILLIUNIT: Balance = UNIT / 1000; + pub const MICROUNIT: Balance = MILLIUNIT / 1000; + + pub const fn deposit(items: u32, bytes: u32) -> Balance { + items as Balance * 2 * UNIT + (bytes as Balance) * 300 * MICROUNIT + } +} + +pub use currency::*; + // To learn more about runtime versioning, see: // https://docs.substrate.io/main-docs/build/upgrade#runtime-versioning #[sp_version::runtime_version] @@ -97,11 +113,6 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { spec_name: create_runtime_str!("xsocial"), impl_name: create_runtime_str!("subsocial-xsocial-testnet"), authoring_version: 1, - // The version of the runtime specification. A full node will not attempt to use its native - // runtime in substitute for the on-chain Wasm runtime unless all of `spec_name`, - // `spec_version`, and `authoring_version` are the same between Wasm and native. - // This value is set to 100 to notify Polkadot-JS App (https://polkadot.js.org/apps) to use - // the compatible custom types. spec_version: 100, impl_version: 1, apis: RUNTIME_API_VERSIONS, @@ -119,7 +130,7 @@ pub const MILLISECS_PER_BLOCK: u64 = 1000; // NOTE: Currently it is not possible to change the slot duration after the chain has started. // Attempting to do so will brick block production. -pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK; +pub const SLOT_DURATION: u64 = 2 * MILLISECS_PER_BLOCK; // Time is measured by number of blocks. pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber); @@ -238,7 +249,7 @@ impl pallet_timestamp::Config for Runtime { } /// Existential deposit. -pub const EXISTENTIAL_DEPOSIT: u128 = 500; +pub const EXISTENTIAL_DEPOSIT: u128 = 10 * MILLIUNIT; impl pallet_balances::Config for Runtime { type MaxLocks = ConstU32<50>; @@ -255,6 +266,7 @@ impl pallet_balances::Config for Runtime { } parameter_types! { + pub const TransactionByteFee: Balance = MILLIUNIT / 10; pub FeeMultiplier: Multiplier = Multiplier::one(); } @@ -263,7 +275,7 @@ impl pallet_transaction_payment::Config for Runtime { type OnChargeTransaction = CurrencyAdapter; type OperationalFeeMultiplier = ConstU8<5>; type WeightToFee = IdentityFee; - type LengthToFee = IdentityFee; + type LengthToFee = ConstantMultiplier; type FeeMultiplierUpdate = ConstFeeMultiplier; } From b53fbf5a79d5f90d687ba1c2c35a19828ba4a6c1 Mon Sep 17 00:00:00 2001 From: Tarek Mohamed Abdalla Date: Thu, 9 Mar 2023 13:33:25 +0200 Subject: [PATCH 10/13] add energy --- Cargo.lock | 84 +++++++++++++++++++++++++++------------------- runtime/Cargo.toml | 3 ++ runtime/src/lib.rs | 19 ++++++++++- 3 files changed, 71 insertions(+), 35 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index cf229c7..7b284ee 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1824,7 +1824,7 @@ checksum = "6c2141d6d6c8512188a7891b4b01590a45f6dac67afb4f255c4124dbb86d4eaa" [[package]] name = "frame-benchmarking" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-support", "frame-system", @@ -1939,7 +1939,7 @@ dependencies = [ [[package]] name = "frame-support" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "bitflags", "frame-metadata", @@ -1971,7 +1971,7 @@ dependencies = [ [[package]] name = "frame-support-procedural" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "Inflector", "cfg-expr", @@ -1985,7 +1985,7 @@ dependencies = [ [[package]] name = "frame-support-procedural-tools" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-support-procedural-tools-derive", "proc-macro-crate", @@ -1997,7 +1997,7 @@ dependencies = [ [[package]] name = "frame-support-procedural-tools-derive" version = "3.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "proc-macro2", "quote", @@ -2007,7 +2007,7 @@ dependencies = [ [[package]] name = "frame-system" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-support", "log", @@ -4229,6 +4229,21 @@ dependencies = [ "sp-std", ] +[[package]] +name = "pallet-energy" +version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "pallet-transaction-payment", + "parity-scale-codec", + "scale-info", + "sp-runtime", + "sp-std", +] + [[package]] name = "pallet-grandpa" version = "4.0.0-dev" @@ -4389,7 +4404,7 @@ dependencies = [ [[package]] name = "pallet-timestamp" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-benchmarking", "frame-support", @@ -6858,7 +6873,7 @@ dependencies = [ [[package]] name = "sp-api" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "hash-db", "log", @@ -6876,7 +6891,7 @@ dependencies = [ [[package]] name = "sp-api-proc-macro" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "blake2", "proc-macro-crate", @@ -6888,7 +6903,7 @@ dependencies = [ [[package]] name = "sp-application-crypto" version = "7.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", "scale-info", @@ -6901,7 +6916,7 @@ dependencies = [ [[package]] name = "sp-arithmetic" version = "6.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "integer-sqrt", "num-traits", @@ -7005,7 +7020,7 @@ dependencies = [ [[package]] name = "sp-core" version = "7.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "array-bytes", "base58", @@ -7047,7 +7062,7 @@ dependencies = [ [[package]] name = "sp-core-hashing" version = "5.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "blake2", "byteorder", @@ -7061,7 +7076,7 @@ dependencies = [ [[package]] name = "sp-core-hashing-proc-macro" version = "5.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "proc-macro2", "quote", @@ -7081,7 +7096,7 @@ dependencies = [ [[package]] name = "sp-debug-derive" version = "5.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "proc-macro2", "quote", @@ -7091,7 +7106,7 @@ dependencies = [ [[package]] name = "sp-externalities" version = "0.13.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "environmental", "parity-scale-codec", @@ -7120,7 +7135,7 @@ dependencies = [ [[package]] name = "sp-inherents" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "impl-trait-for-tuples", @@ -7134,7 +7149,7 @@ dependencies = [ [[package]] name = "sp-io" version = "7.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "bytes", "ed25519", @@ -7170,7 +7185,7 @@ dependencies = [ [[package]] name = "sp-keystore" version = "0.13.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "futures", @@ -7206,7 +7221,7 @@ dependencies = [ [[package]] name = "sp-panic-handler" version = "5.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "backtrace", "lazy_static", @@ -7226,7 +7241,7 @@ dependencies = [ [[package]] name = "sp-runtime" version = "7.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "either", "hash256-std-hasher", @@ -7248,7 +7263,7 @@ dependencies = [ [[package]] name = "sp-runtime-interface" version = "7.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "bytes", "impl-trait-for-tuples", @@ -7266,7 +7281,7 @@ dependencies = [ [[package]] name = "sp-runtime-interface-proc-macro" version = "6.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "Inflector", "proc-macro-crate", @@ -7292,7 +7307,7 @@ dependencies = [ [[package]] name = "sp-staking" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", "scale-info", @@ -7304,7 +7319,7 @@ dependencies = [ [[package]] name = "sp-state-machine" version = "0.13.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "hash-db", "log", @@ -7324,12 +7339,12 @@ dependencies = [ [[package]] name = "sp-std" version = "5.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" [[package]] name = "sp-storage" version = "7.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "impl-serde", "parity-scale-codec", @@ -7342,7 +7357,7 @@ dependencies = [ [[package]] name = "sp-timestamp" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "futures-timer", @@ -7357,7 +7372,7 @@ dependencies = [ [[package]] name = "sp-tracing" version = "6.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", "sp-std", @@ -7394,7 +7409,7 @@ dependencies = [ [[package]] name = "sp-trie" version = "7.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "ahash", "hash-db", @@ -7417,7 +7432,7 @@ dependencies = [ [[package]] name = "sp-version" version = "5.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "impl-serde", "parity-scale-codec", @@ -7434,7 +7449,7 @@ dependencies = [ [[package]] name = "sp-version-proc-macro" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", "proc-macro2", @@ -7445,7 +7460,7 @@ dependencies = [ [[package]] name = "sp-wasm-interface" version = "7.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "impl-trait-for-tuples", "log", @@ -7458,7 +7473,7 @@ dependencies = [ [[package]] name = "sp-weights" version = "4.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", "scale-info", @@ -9419,6 +9434,7 @@ dependencies = [ "frame-try-runtime", "pallet-aura", "pallet-balances", + "pallet-energy", "pallet-grandpa", "pallet-permissions", "pallet-posts", diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 83ae6b2..2238910 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -52,6 +52,7 @@ pallet-spaces = { default-features = false, git = "https://github.com/dappforce/ pallet-posts = { default-features = false, git = "https://github.com/dappforce/subsocial-parachain.git", rev = "035c651a03ba94d78f1d5dbc87a5f4461cfbb664" } pallet-roles = { default-features = false, git = "https://github.com/dappforce/subsocial-parachain.git", rev = "035c651a03ba94d78f1d5dbc87a5f4461cfbb664" } pallet-space-follows = { default-features = false, git = "https://github.com/dappforce/subsocial-parachain.git", rev = "035c651a03ba94d78f1d5dbc87a5f4461cfbb664" } +pallet-energy = { default-features = false, git = "https://github.com/dappforce/subsocial-parachain.git", rev = "035c651a03ba94d78f1d5dbc87a5f4461cfbb664" } [build-dependencies] substrate-wasm-builder = { version = "5.0.0-dev", git = "https://github.com/paritytech/substrate.git", optional = true, branch = "polkadot-v0.9.37" } @@ -94,6 +95,7 @@ std = [ "pallet-roles/std", "pallet-posts/std", "pallet-space-follows/std", + "pallet-energy/std", ] runtime-benchmarks = [ "frame-benchmarking/runtime-benchmarks", @@ -120,6 +122,7 @@ try-runtime = [ "pallet-roles/try-runtime", "pallet-space-follows/try-runtime", "pallet-posts/try-runtime", + "pallet-energy/try-runtime", "pallet-timestamp/try-runtime", "pallet-transaction-payment/try-runtime", ] diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index b02de23..b257202 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -41,6 +41,7 @@ pub use frame_support::{ }; use frame_support::weights::ConstantMultiplier; pub use frame_system::Call as SystemCall; +use frame_system::EnsureRoot; pub use pallet_balances::Call as BalancesCall; pub use pallet_timestamp::Call as TimestampCall; use pallet_transaction_payment::{ConstFeeMultiplier, CurrencyAdapter, Multiplier}; @@ -272,7 +273,7 @@ parameter_types! { impl pallet_transaction_payment::Config for Runtime { type RuntimeEvent = RuntimeEvent; - type OnChargeTransaction = CurrencyAdapter; + type OnChargeTransaction = Energy; type OperationalFeeMultiplier = ConstU8<5>; type WeightToFee = IdentityFee; type LengthToFee = ConstantMultiplier; @@ -334,6 +335,21 @@ impl pallet_space_follows::Config for Runtime { type WeightInfo = pallet_space_follows::weights::SubstrateWeight; } +parameter_types! { + pub DefaultValueCoefficient: FixedI64 = FixedI64::checked_from_rational(1_25, 100).unwrap(); +} + +impl pallet_energy::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + type Balance = Balance; + type DefaultValueCoefficient = DefaultValueCoefficient; + type UpdateOrigin = EnsureRoot; + type NativeOnChargeTransaction = pallet_transaction_payment::CurrencyAdapter; + type ExistentialDeposit = ExistentialDeposit; + type WeightInfo = pallet_energy::weights::SubstrateWeight; +} + // Create the runtime by composing the FRAME pallets that were previously configured. construct_runtime!( pub struct Runtime @@ -356,6 +372,7 @@ construct_runtime!( Roles: pallet_roles, SpaceFollows: pallet_space_follows, Posts: pallet_posts, + Energy: pallet_energy, } ); From 73af1b5cb52708d479f72e46b3d15a17d6f8c62a Mon Sep 17 00:00:00 2001 From: Vlad Proshchavaiev <32250097+F3Joule@users.noreply.github.com> Date: Thu, 9 Mar 2023 14:14:28 +0200 Subject: [PATCH 11/13] Fix runtime --- runtime/src/lib.rs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index b257202..d21eb9b 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -18,7 +18,7 @@ use sp_runtime::{ AccountIdLookup, BlakeTwo256, Block as BlockT, IdentifyAccount, NumberFor, One, Verify, }, transaction_validity::{TransactionSource, TransactionValidity}, - ApplyExtrinsicResult, MultiSignature, + ApplyExtrinsicResult, MultiSignature, FixedI64, FixedPointNumber, }; use sp_std::prelude::*; #[cfg(feature = "std")] @@ -44,7 +44,7 @@ pub use frame_system::Call as SystemCall; use frame_system::EnsureRoot; pub use pallet_balances::Call as BalancesCall; pub use pallet_timestamp::Call as TimestampCall; -use pallet_transaction_payment::{ConstFeeMultiplier, CurrencyAdapter, Multiplier}; +use pallet_transaction_payment::{ConstFeeMultiplier, Multiplier}; #[cfg(any(feature = "std", test))] pub use sp_runtime::BuildStorage; pub use sp_runtime::{Perbill, Permill}; @@ -336,6 +336,7 @@ impl pallet_space_follows::Config for Runtime { } parameter_types! { + pub const ExistentialDeposit: Balance = EXISTENTIAL_DEPOSIT; pub DefaultValueCoefficient: FixedI64 = FixedI64::checked_from_rational(1_25, 100).unwrap(); } From cf263b504439803b874742ec10c34e7e192fb201 Mon Sep 17 00:00:00 2001 From: Tarek Mohamed Abdalla Date: Fri, 10 Mar 2023 10:11:56 +0200 Subject: [PATCH 12/13] tmp commit: babe --- Cargo.lock | 258 ++++++++++++++++++++++++++--------------- node/Cargo.toml | 4 +- node/src/chain_spec.rs | 47 ++++---- runtime/Cargo.toml | 21 +++- runtime/src/lib.rs | 118 ++++++++++++++++--- 5 files changed, 307 insertions(+), 141 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7b284ee..b22d474 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1801,7 +1801,7 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" [[package]] name = "fork-tree" version = "3.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", ] @@ -1847,7 +1847,7 @@ dependencies = [ [[package]] name = "frame-benchmarking-cli" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "Inflector", "array-bytes", @@ -1894,7 +1894,7 @@ dependencies = [ [[package]] name = "frame-executive" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-support", "frame-system", @@ -1923,7 +1923,7 @@ dependencies = [ [[package]] name = "frame-remote-externalities" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "futures", "log", @@ -2025,7 +2025,7 @@ dependencies = [ [[package]] name = "frame-system-benchmarking" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-benchmarking", "frame-support", @@ -2040,7 +2040,7 @@ dependencies = [ [[package]] name = "frame-system-rpc-runtime-api" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", "sp-api", @@ -2049,7 +2049,7 @@ dependencies = [ [[package]] name = "frame-try-runtime" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-support", "parity-scale-codec", @@ -4184,48 +4184,75 @@ dependencies = [ ] [[package]] -name = "pallet-aura" +name = "pallet-authorship" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-support", "frame-system", - "pallet-timestamp", + "impl-trait-for-tuples", "parity-scale-codec", "scale-info", - "sp-application-crypto", - "sp-consensus-aura", + "sp-authorship", "sp-runtime", "sp-std", ] [[package]] -name = "pallet-authorship" +name = "pallet-babe" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ + "frame-benchmarking", "frame-support", "frame-system", - "impl-trait-for-tuples", + "log", + "pallet-authorship", + "pallet-session", + "pallet-timestamp", "parity-scale-codec", "scale-info", - "sp-authorship", + "sp-application-crypto", + "sp-consensus-babe", + "sp-consensus-vrf", + "sp-io", "sp-runtime", + "sp-session", + "sp-staking", "sp-std", ] [[package]] name = "pallet-balances" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-collator-selection" +version = "3.0.0" +source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.37#09418fc04c2608b123f36ca80f16df3d2096753b" dependencies = [ "frame-benchmarking", "frame-support", "frame-system", "log", + "pallet-authorship", + "pallet-session", "parity-scale-codec", + "rand 0.8.5", "scale-info", "sp-runtime", + "sp-staking", "sp-std", ] @@ -4247,7 +4274,7 @@ dependencies = [ [[package]] name = "pallet-grandpa" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-benchmarking", "frame-support", @@ -4305,7 +4332,7 @@ dependencies = [ [[package]] name = "pallet-randomness-collective-flip" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-support", "frame-system", @@ -4336,7 +4363,7 @@ dependencies = [ [[package]] name = "pallet-session" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-support", "frame-system", @@ -4390,7 +4417,7 @@ dependencies = [ [[package]] name = "pallet-sudo" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-support", "frame-system", @@ -4422,7 +4449,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-support", "frame-system", @@ -4438,7 +4465,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment-rpc" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "jsonrpsee", "pallet-transaction-payment-rpc-runtime-api", @@ -4454,7 +4481,7 @@ dependencies = [ [[package]] name = "pallet-transaction-payment-rpc-runtime-api" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "pallet-transaction-payment", "parity-scale-codec", @@ -5563,7 +5590,7 @@ dependencies = [ [[package]] name = "sc-allocator" version = "4.1.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "log", "sp-core", @@ -5574,7 +5601,7 @@ dependencies = [ [[package]] name = "sc-basic-authorship" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "futures", "futures-timer", @@ -5597,7 +5624,7 @@ dependencies = [ [[package]] name = "sc-block-builder" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", "sc-client-api", @@ -5613,7 +5640,7 @@ dependencies = [ [[package]] name = "sc-chain-spec" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "memmap2", "sc-chain-spec-derive", @@ -5628,7 +5655,7 @@ dependencies = [ [[package]] name = "sc-chain-spec-derive" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "proc-macro-crate", "proc-macro2", @@ -5639,7 +5666,7 @@ dependencies = [ [[package]] name = "sc-cli" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "array-bytes", "chrono", @@ -5679,7 +5706,7 @@ dependencies = [ [[package]] name = "sc-client-api" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "fnv", "futures", @@ -5705,7 +5732,7 @@ dependencies = [ [[package]] name = "sc-client-db" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "hash-db", "kvdb", @@ -5730,7 +5757,7 @@ dependencies = [ [[package]] name = "sc-consensus" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "futures", @@ -5753,26 +5780,35 @@ dependencies = [ ] [[package]] -name = "sc-consensus-aura" +name = "sc-consensus-babe" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", + "fork-tree", "futures", "log", + "merlin", + "num-bigint", + "num-rational", + "num-traits", "parity-scale-codec", - "sc-block-builder", + "parking_lot 0.12.1", "sc-client-api", "sc-consensus", + "sc-consensus-epochs", "sc-consensus-slots", + "sc-keystore", "sc-telemetry", + "schnorrkel", "sp-api", "sp-application-crypto", "sp-block-builder", "sp-blockchain", "sp-consensus", - "sp-consensus-aura", + "sp-consensus-babe", "sp-consensus-slots", + "sp-consensus-vrf", "sp-core", "sp-inherents", "sp-keystore", @@ -5781,10 +5817,23 @@ dependencies = [ "thiserror", ] +[[package]] +name = "sc-consensus-epochs" +version = "0.10.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "fork-tree", + "parity-scale-codec", + "sc-client-api", + "sc-consensus", + "sp-blockchain", + "sp-runtime", +] + [[package]] name = "sc-consensus-slots" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "futures", @@ -5807,7 +5856,7 @@ dependencies = [ [[package]] name = "sc-executor" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "lru", "parity-scale-codec", @@ -5831,7 +5880,7 @@ dependencies = [ [[package]] name = "sc-executor-common" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "sc-allocator", "sp-maybe-compressed-blob", @@ -5844,7 +5893,7 @@ dependencies = [ [[package]] name = "sc-executor-wasmi" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "log", "sc-allocator", @@ -5857,7 +5906,7 @@ dependencies = [ [[package]] name = "sc-executor-wasmtime" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "cfg-if", "libc", @@ -5874,7 +5923,7 @@ dependencies = [ [[package]] name = "sc-finality-grandpa" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "ahash", "array-bytes", @@ -5914,7 +5963,7 @@ dependencies = [ [[package]] name = "sc-informant" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "ansi_term", "futures", @@ -5929,7 +5978,7 @@ dependencies = [ [[package]] name = "sc-keystore" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "array-bytes", "async-trait", @@ -5944,7 +5993,7 @@ dependencies = [ [[package]] name = "sc-network" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "array-bytes", "async-trait", @@ -5986,7 +6035,7 @@ dependencies = [ [[package]] name = "sc-network-bitswap" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "cid", "futures", @@ -6005,7 +6054,7 @@ dependencies = [ [[package]] name = "sc-network-common" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "bitflags", @@ -6031,7 +6080,7 @@ dependencies = [ [[package]] name = "sc-network-gossip" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "ahash", "futures", @@ -6049,7 +6098,7 @@ dependencies = [ [[package]] name = "sc-network-light" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "array-bytes", "futures", @@ -6070,7 +6119,7 @@ dependencies = [ [[package]] name = "sc-network-sync" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "array-bytes", "async-trait", @@ -6102,7 +6151,7 @@ dependencies = [ [[package]] name = "sc-network-transactions" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "array-bytes", "futures", @@ -6121,7 +6170,7 @@ dependencies = [ [[package]] name = "sc-offchain" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "array-bytes", "bytes", @@ -6151,7 +6200,7 @@ dependencies = [ [[package]] name = "sc-peerset" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "futures", "libp2p", @@ -6164,7 +6213,7 @@ dependencies = [ [[package]] name = "sc-proposer-metrics" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "log", "substrate-prometheus-endpoint", @@ -6173,7 +6222,7 @@ dependencies = [ [[package]] name = "sc-rpc" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "futures", "jsonrpsee", @@ -6202,7 +6251,7 @@ dependencies = [ [[package]] name = "sc-rpc-api" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "jsonrpsee", "parity-scale-codec", @@ -6221,7 +6270,7 @@ dependencies = [ [[package]] name = "sc-rpc-server" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "http", "jsonrpsee", @@ -6236,7 +6285,7 @@ dependencies = [ [[package]] name = "sc-rpc-spec-v2" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "array-bytes", "futures", @@ -6262,7 +6311,7 @@ dependencies = [ [[package]] name = "sc-service" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "directories", @@ -6327,7 +6376,7 @@ dependencies = [ [[package]] name = "sc-state-db" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "log", "parity-scale-codec", @@ -6338,7 +6387,7 @@ dependencies = [ [[package]] name = "sc-sysinfo" version = "6.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "futures", "libc", @@ -6357,7 +6406,7 @@ dependencies = [ [[package]] name = "sc-telemetry" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "chrono", "futures", @@ -6376,7 +6425,7 @@ dependencies = [ [[package]] name = "sc-tracing" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "ansi_term", "atty", @@ -6407,7 +6456,7 @@ dependencies = [ [[package]] name = "sc-tracing-proc-macro" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "proc-macro-crate", "proc-macro2", @@ -6418,7 +6467,7 @@ dependencies = [ [[package]] name = "sc-transaction-pool" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "futures", @@ -6444,7 +6493,7 @@ dependencies = [ [[package]] name = "sc-transaction-pool-api" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "futures", @@ -6458,7 +6507,7 @@ dependencies = [ [[package]] name = "sc-utils" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "backtrace", "futures", @@ -6930,7 +6979,7 @@ dependencies = [ [[package]] name = "sp-authorship" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "parity-scale-codec", @@ -6942,7 +6991,7 @@ dependencies = [ [[package]] name = "sp-block-builder" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", "sp-api", @@ -6954,7 +7003,7 @@ dependencies = [ [[package]] name = "sp-blockchain" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "futures", "log", @@ -6972,7 +7021,7 @@ dependencies = [ [[package]] name = "sp-consensus" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "futures", @@ -6988,18 +7037,23 @@ dependencies = [ ] [[package]] -name = "sp-consensus-aura" +name = "sp-consensus-babe" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", + "merlin", "parity-scale-codec", "scale-info", + "serde", "sp-api", "sp-application-crypto", "sp-consensus", "sp-consensus-slots", + "sp-consensus-vrf", + "sp-core", "sp-inherents", + "sp-keystore", "sp-runtime", "sp-std", "sp-timestamp", @@ -7008,7 +7062,7 @@ dependencies = [ [[package]] name = "sp-consensus-slots" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", "scale-info", @@ -7017,6 +7071,19 @@ dependencies = [ "sp-timestamp", ] +[[package]] +name = "sp-consensus-vrf" +version = "0.10.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "parity-scale-codec", + "scale-info", + "schnorrkel", + "sp-core", + "sp-runtime", + "sp-std", +] + [[package]] name = "sp-core" version = "7.0.0" @@ -7087,7 +7154,7 @@ dependencies = [ [[package]] name = "sp-database" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "kvdb", "parking_lot 0.12.1", @@ -7117,7 +7184,7 @@ dependencies = [ [[package]] name = "sp-finality-grandpa" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "finality-grandpa", "log", @@ -7174,7 +7241,7 @@ dependencies = [ [[package]] name = "sp-keyring" version = "7.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "lazy_static", "sp-core", @@ -7202,7 +7269,7 @@ dependencies = [ [[package]] name = "sp-maybe-compressed-blob" version = "4.1.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "thiserror", "zstd", @@ -7211,7 +7278,7 @@ dependencies = [ [[package]] name = "sp-offchain" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "sp-api", "sp-core", @@ -7231,7 +7298,7 @@ dependencies = [ [[package]] name = "sp-rpc" version = "6.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "rustc-hash", "serde", @@ -7293,7 +7360,7 @@ dependencies = [ [[package]] name = "sp-session" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "parity-scale-codec", "scale-info", @@ -7384,7 +7451,7 @@ dependencies = [ [[package]] name = "sp-transaction-pool" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "sp-api", "sp-runtime", @@ -7393,7 +7460,7 @@ dependencies = [ [[package]] name = "sp-transaction-storage-proof" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "log", @@ -7646,7 +7713,7 @@ dependencies = [ [[package]] name = "substrate-build-script-utils" version = "3.0.0" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "platforms 2.0.0", ] @@ -7654,7 +7721,7 @@ dependencies = [ [[package]] name = "substrate-frame-rpc-system" version = "4.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-system-rpc-runtime-api", "futures", @@ -7673,7 +7740,7 @@ dependencies = [ [[package]] name = "substrate-prometheus-endpoint" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "hyper", "log", @@ -7685,7 +7752,7 @@ dependencies = [ [[package]] name = "substrate-rpc-client" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "async-trait", "jsonrpsee", @@ -7698,7 +7765,7 @@ dependencies = [ [[package]] name = "substrate-wasm-builder" version = "5.0.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "ansi_term", "build-helper", @@ -8232,7 +8299,7 @@ checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed" [[package]] name = "try-runtime-cli" version = "0.10.0-dev" -source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#946507ba9ef13e263534176b7b74e26fc56efbd4" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "clap", "frame-remote-externalities", @@ -9393,7 +9460,7 @@ dependencies = [ "sc-cli", "sc-client-api", "sc-consensus", - "sc-consensus-aura", + "sc-consensus-babe", "sc-executor", "sc-finality-grandpa", "sc-keystore", @@ -9407,7 +9474,7 @@ dependencies = [ "sp-block-builder", "sp-blockchain", "sp-consensus", - "sp-consensus-aura", + "sp-consensus-babe", "sp-core", "sp-finality-grandpa", "sp-inherents", @@ -9432,14 +9499,17 @@ dependencies = [ "frame-system-benchmarking", "frame-system-rpc-runtime-api", "frame-try-runtime", - "pallet-aura", + "pallet-authorship", + "pallet-babe", "pallet-balances", + "pallet-collator-selection", "pallet-energy", "pallet-grandpa", "pallet-permissions", "pallet-posts", "pallet-randomness-collective-flip", "pallet-roles", + "pallet-session", "pallet-space-follows", "pallet-spaces", "pallet-sudo", @@ -9450,7 +9520,7 @@ dependencies = [ "scale-info", "sp-api", "sp-block-builder", - "sp-consensus-aura", + "sp-consensus-babe", "sp-core", "sp-inherents", "sp-offchain", diff --git a/node/Cargo.toml b/node/Cargo.toml index a4e45e9..2eb87f6 100644 --- a/node/Cargo.toml +++ b/node/Cargo.toml @@ -29,8 +29,8 @@ sc-telemetry = { version = "4.0.0-dev", git = "https://github.com/paritytech/sub sc-keystore = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sc-transaction-pool = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sc-transaction-pool-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-consensus-aura = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-consensus-aura = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus-babe = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-consensus-babe = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sp-consensus = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sc-consensus = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sc-finality-grandpa = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } diff --git a/node/src/chain_spec.rs b/node/src/chain_spec.rs index 7844999..ce0bafe 100644 --- a/node/src/chain_spec.rs +++ b/node/src/chain_spec.rs @@ -1,13 +1,12 @@ -use xsocial_runtime::{AccountId, AuraConfig, BalancesConfig, GenesisConfig, GrandpaConfig, Signature, SudoConfig, SystemConfig, UNIT, WASM_BINARY}; +use xsocial_runtime::{AccountId, BalancesConfig, CollatorSelectionConfig, EXISTENTIAL_DEPOSIT, GenesisConfig, GrandpaConfig, Signature, SudoConfig, SystemConfig, UNIT, WASM_BINARY}; use sc_service::ChainType; use sc_chain_spec::Properties; use sc_telemetry::TelemetryEndpoints; -use sp_consensus_aura::sr25519::AuthorityId as AuraId; +use sp_consensus_babe::AuthorityId as BabeId; use sp_core::{sr25519, Pair, Public}; use sp_finality_grandpa::AuthorityId as GrandpaId; use sp_runtime::traits::{IdentifyAccount, Verify}; use hex_literal::hex; -use sp_core::crypto::UncheckedInto; // The URL for the telemetry server. const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/"; @@ -33,9 +32,9 @@ where AccountPublic::from(get_from_seed::(seed)).into_account() } -/// Generate an Aura authority key. -pub fn authority_keys_from_seed(s: &str) -> (AuraId, GrandpaId) { - (get_from_seed::(s), get_from_seed::(s)) +/// Generate an Babe authority key. +pub fn authority_keys_from_seed(s: &str) -> (AccountId, BabeId, GrandpaId) { + (get_account_id_from_seed::(s), get_from_seed::(s), get_from_seed::(s)) } pub fn development_config() -> Result { @@ -141,21 +140,21 @@ pub fn staging_testnet_config() -> Result { ChainType::Live, move || { let root_key: AccountId = hex!["a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45"].into(); - let initial_authorities: Vec<(AuraId, GrandpaId)> = vec![ - ( - hex!["d4f4482d82913b5a4ef195bba7ec5567ee04b6ea784139c04ee5e77530670149"].unchecked_into(), - hex!["419c48625508cc74c8c125dd0132158d3583b479975e516c3c2cc1457d11a7c5"].unchecked_into(), - ), - ( - hex!["640f97526d653b620d1ccbdefa4cb212cc0dfc76f77a0f631f96f009d986464b"].unchecked_into(), - hex!["b553650f5032ecadba5df3bd35e8d280bc6f5cdff1beda8c504d6cfecc89c63a"].unchecked_into(), - ), + let initial_authorities: Vec<(BabeId, GrandpaId)> = vec![ + // TODO: fix + // ( + // hex!["d4f4482d82913b5a4ef195bba7ec5567ee04b6ea784139c04ee5e77530670149"].unchecked_into(), + // hex!["419c48625508cc74c8c125dd0132158d3583b479975e516c3c2cc1457d11a7c5"].unchecked_into(), + // ), + // ( + // hex!["640f97526d653b620d1ccbdefa4cb212cc0dfc76f77a0f631f96f009d986464b"].unchecked_into(), + // hex!["b553650f5032ecadba5df3bd35e8d280bc6f5cdff1beda8c504d6cfecc89c63a"].unchecked_into(), + // ), ]; - testnet_genesis( wasm_binary, // Initial PoA authorities - initial_authorities, + Default::default(), // Sudo account root_key.clone(), // Pre-funded accounts @@ -180,7 +179,7 @@ pub fn staging_testnet_config() -> Result { /// Configure initial storage state for FRAME modules. fn testnet_genesis( wasm_binary: &[u8], - initial_authorities: Vec<(AuraId, GrandpaId)>, + invulnerables: Vec<(AccountId, BabeId, GrandpaId)>, root_key: AccountId, endowed_accounts: Vec, _enable_println: bool, @@ -190,15 +189,18 @@ fn testnet_genesis( // Add Wasm runtime to storage. code: wasm_binary.to_vec(), }, + collator_selection: CollatorSelectionConfig { + invulnerables: invulnerables.iter().cloned().map(|(acc, _, _)| acc).collect(), + candidacy_bond: EXISTENTIAL_DEPOSIT * 16, + ..Default::default() + }, + session: Default::default(), balances: BalancesConfig { // Configure endowed accounts with initial balance of 1 << 60. balances: endowed_accounts.iter().cloned().map(|k| (k, 1_000_000 * UNIT)).collect(), }, - aura: AuraConfig { - authorities: initial_authorities.iter().map(|x| (x.0.clone())).collect(), - }, grandpa: GrandpaConfig { - authorities: initial_authorities.iter().map(|x| (x.1.clone(), 1)).collect(), + authorities: invulnerables.iter().map(|x| (x.2.clone(), 1)).collect(), }, sudo: SudoConfig { // Assign network admin rights. @@ -208,6 +210,7 @@ fn testnet_genesis( spaces: xsocial_runtime::SpacesConfig { endowed_account: Some(root_key), }, + babe: Default::default(), } } diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 2238910..0461111 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -15,7 +15,6 @@ targets = ["x86_64-unknown-linux-gnu"] codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = ["derive"] } scale-info = { version = "2.1.1", default-features = false, features = ["derive"] } -pallet-aura = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } pallet-balances = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } frame-support = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } pallet-grandpa = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } @@ -24,11 +23,14 @@ pallet-sudo = { version = "4.0.0-dev", default-features = false, git = "https:// frame-system = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } frame-try-runtime = { version = "0.10.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", optional = true, branch = "polkadot-v0.9.37" } pallet-timestamp = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-babe = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-session = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-authorship = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.37" } pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } frame-executive = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sp-api = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sp-block-builder = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-consensus-aura = { version = "0.10.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-consensus-babe = { version = "0.10.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sp-core = { version = "7.0.0", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sp-inherents = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sp-offchain = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } @@ -38,6 +40,9 @@ sp-std = { version = "5.0.0", default-features = false, git = "https://github.co sp-transaction-pool = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } sp-version = { version = "5.0.0", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-collator-selection = { git = "https://github.com/paritytech/cumulus", default-features = false, branch = "polkadot-v0.9.37" } + + # Used for the node's RPCs frame-system-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } pallet-transaction-payment-rpc-runtime-api = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } @@ -70,7 +75,6 @@ std = [ "frame-system-rpc-runtime-api/std", "frame-system/std", "frame-try-runtime/std", - "pallet-aura/std", "pallet-balances/std", "pallet-grandpa/std", "pallet-randomness-collective-flip/std", @@ -80,7 +84,7 @@ std = [ "pallet-transaction-payment/std", "sp-api/std", "sp-block-builder/std", - "sp-consensus-aura/std", + "sp-consensus-babe/std", "sp-core/std", "sp-inherents/std", "sp-offchain/std", @@ -96,6 +100,10 @@ std = [ "pallet-posts/std", "pallet-space-follows/std", "pallet-energy/std", + "pallet-babe/std", + "pallet-session/std", + "pallet-authorship/std", + "pallet-collator-selection/std", ] runtime-benchmarks = [ "frame-benchmarking/runtime-benchmarks", @@ -112,7 +120,10 @@ try-runtime = [ "frame-executive/try-runtime", "frame-system/try-runtime", "frame-support/try-runtime", - "pallet-aura/try-runtime", + "pallet-babe/try-runtime", + "pallet-session/try-runtime", + "pallet-authorship/try-runtime", + "pallet-collator-selection/try-runtime", "pallet-balances/try-runtime", "pallet-grandpa/try-runtime", "pallet-randomness-collective-flip/try-runtime", diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index d21eb9b..7b07873 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -10,7 +10,7 @@ use pallet_grandpa::{ fg_primitives, AuthorityId as GrandpaId, AuthorityList as GrandpaAuthorityList, }; use sp_api::impl_runtime_apis; -use sp_consensus_aura::sr25519::AuthorityId as AuraId; +use frame_support::PalletId; use sp_core::{crypto::KeyTypeId, OpaqueMetadata}; use sp_runtime::{ create_runtime_str, generic, impl_opaque_keys, @@ -86,8 +86,8 @@ pub mod opaque { impl_opaque_keys! { pub struct SessionKeys { - pub aura: Aura, pub grandpa: Grandpa, + pub babe: Babe, } } } @@ -133,6 +133,13 @@ pub const MILLISECS_PER_BLOCK: u64 = 1000; // Attempting to do so will brick block production. pub const SLOT_DURATION: u64 = 2 * MILLISECS_PER_BLOCK; +pub const EPOCH_DURATION_IN_BLOCKS: BlockNumber = 10 * MINUTES; +pub const EPOCH_DURATION_IN_SLOTS: u64 = { + const SLOT_FILL_RATE: f64 = MILLISECS_PER_BLOCK as f64 / SLOT_DURATION as f64; + + (EPOCH_DURATION_IN_BLOCKS as f64 * SLOT_FILL_RATE) as u64 +}; + // Time is measured by number of blocks. pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber); pub const HOURS: BlockNumber = MINUTES * 60; @@ -216,10 +223,89 @@ impl frame_system::Config for Runtime { impl pallet_randomness_collective_flip::Config for Runtime {} -impl pallet_aura::Config for Runtime { - type AuthorityId = AuraId; - type DisabledValidators = (); - type MaxAuthorities = ConstU32<32>; +parameter_types! { + // NOTE: Currently it is not possible to change the epoch duration after the chain has started. + // Attempting to do so will brick block production. + pub const EpochDuration: u64 = EPOCH_DURATION_IN_SLOTS; + pub const ExpectedBlockTime: u64 = MILLISECS_PER_BLOCK; + pub const MaxAuthorities: u32 = 100_000; +} + + + +impl pallet_babe::Config for Runtime { + type EpochDuration = EpochDuration; + type ExpectedBlockTime = ExpectedBlockTime; + type EpochChangeTrigger = pallet_babe::ExternalTrigger; + type DisabledValidators = Session; + type KeyOwnerProof = >::Proof; + + type KeyOwnerIdentification = >::IdentificationTuple; + + type HandleEquivocation = (); // no offences are implemented + type KeyOwnerProofSystem = (); // no offences are implemented + + type WeightInfo = (); + type MaxAuthorities = MaxAuthorities; +} + +parameter_types! { + pub const Period: u32 = 6 * HOURS; +} + + +impl pallet_session::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type ValidatorId = ::AccountId; + // we don't have stash and controller, thus we don't need the convert as well. + type ValidatorIdOf = pallet_collator_selection::IdentityCollator; + type ShouldEndSession = Babe; + type NextSessionRotation = Babe; + type SessionManager = CollatorSelection; + type SessionHandler = ::KeyTypeIdProviders; + type Keys = SessionKeys; + type WeightInfo = (); +} + + +parameter_types! { + pub const PotId: PalletId = PalletId(*b"PotStake"); + pub const MaxCandidates: u32 = 1000; + pub const MinCandidates: u32 = 5; + pub const SessionLength: BlockNumber = 6 * HOURS; + pub const MaxInvulnerables: u32 = 100; +} + +// We allow root only to execute privileged collator selection operations. +pub type CollatorSelectionUpdateOrigin = EnsureRoot; + +impl pallet_collator_selection::Config for Runtime { + type RuntimeEvent = RuntimeEvent; + type Currency = Balances; + type UpdateOrigin = CollatorSelectionUpdateOrigin; + type PotId = PotId; + type MaxCandidates = MaxCandidates; + type MinCandidates = MinCandidates; + type MaxInvulnerables = MaxInvulnerables; + // should be a multiple of session or things will get inconsistent + type KickThreshold = Period; + type ValidatorId = ::AccountId; + type ValidatorIdOf = pallet_collator_selection::IdentityCollator; + type ValidatorRegistration = Session; + type WeightInfo = (); +} + +impl pallet_authorship::Config for Runtime { + type FindAuthor = pallet_session::FindAccountFromAuthorIndex; + type UncleGenerations = ConstU32<0>; + type FilterUncle = (); + type EventHandler = (CollatorSelection,); } impl pallet_grandpa::Config for Runtime { @@ -241,10 +327,11 @@ impl pallet_grandpa::Config for Runtime { type MaxAuthorities = ConstU32<32>; } + impl pallet_timestamp::Config for Runtime { /// A timestamp: milliseconds since the unix epoch. type Moment = u64; - type OnTimestampSet = Aura; + type OnTimestampSet = Babe; type MinimumPeriod = ConstU64<{ SLOT_DURATION / 2 }>; type WeightInfo = (); } @@ -286,6 +373,8 @@ impl pallet_sudo::Config for Runtime { } use pallet_permissions::default_permissions::DefaultSpacePermissions; +use sp_runtime::traits::OpaqueKeys; +use opaque::SessionKeys; impl pallet_permissions::Config for Runtime { type DefaultSpacePermissions = DefaultSpacePermissions; @@ -362,7 +451,10 @@ construct_runtime!( System: frame_system, RandomnessCollectiveFlip: pallet_randomness_collective_flip, Timestamp: pallet_timestamp, - Aura: pallet_aura, + Authorship: pallet_authorship, + CollatorSelection: pallet_collator_selection, + Session: pallet_session, + Babe: pallet_babe, Grandpa: pallet_grandpa, Balances: pallet_balances, TransactionPayment: pallet_transaction_payment, @@ -481,16 +573,6 @@ impl_runtime_apis! { } } - impl sp_consensus_aura::AuraApi for Runtime { - fn slot_duration() -> sp_consensus_aura::SlotDuration { - sp_consensus_aura::SlotDuration::from_millis(Aura::slot_duration()) - } - - fn authorities() -> Vec { - Aura::authorities().into_inner() - } - } - impl sp_session::SessionKeys for Runtime { fn generate_session_keys(seed: Option>) -> Vec { opaque::SessionKeys::generate(seed) From f651bc205b6de195e973b6e6ccd1d27fc338b0d6 Mon Sep 17 00:00:00 2001 From: Tarek Mohamed Abdalla Date: Wed, 15 Mar 2023 14:06:11 +0200 Subject: [PATCH 13/13] BABE --- Cargo.lock | 2268 +++++++++++++++++++++++++--- Cargo.toml | 5 +- node/Cargo.toml | 81 - node/build.rs | 7 - node/cli/Cargo.toml | 160 ++ node/cli/bin/main.rs | 25 + node/cli/build.rs | 66 + node/{ => cli}/src/benchmarking.rs | 100 +- node/cli/src/chain_spec.rs | 407 +++++ node/cli/src/cli.rs | 100 ++ node/{ => cli}/src/command.rs | 222 +-- node/cli/src/lib.rs | 47 + node/cli/src/service.rs | 817 ++++++++++ node/executor/Cargo.toml | 50 + node/executor/src/lib.rs | 37 + node/primitives/Cargo.toml | 34 + node/primitives/src/lib.rs | 66 + node/res/xsocial.json | 1055 ------------- node/rpc/Cargo.toml | 40 + node/rpc/src/lib.rs | 184 +++ node/src/chain_spec.rs | 225 --- node/src/cli.rs | 53 - node/src/lib.rs | 3 - node/src/main.rs | 14 - node/src/rpc.rs | 57 - node/src/service.rs | 340 ----- runtime/Cargo.toml | 2 +- runtime/src/lib.rs | 97 +- 28 files changed, 4368 insertions(+), 2194 deletions(-) delete mode 100644 node/Cargo.toml delete mode 100644 node/build.rs create mode 100644 node/cli/Cargo.toml create mode 100644 node/cli/bin/main.rs create mode 100644 node/cli/build.rs rename node/{ => cli}/src/benchmarking.rs (50%) create mode 100644 node/cli/src/chain_spec.rs create mode 100644 node/cli/src/cli.rs rename node/{ => cli}/src/command.rs (57%) create mode 100644 node/cli/src/lib.rs create mode 100644 node/cli/src/service.rs create mode 100644 node/executor/Cargo.toml create mode 100644 node/executor/src/lib.rs create mode 100644 node/primitives/Cargo.toml create mode 100644 node/primitives/src/lib.rs delete mode 100644 node/res/xsocial.json create mode 100644 node/rpc/Cargo.toml create mode 100644 node/rpc/src/lib.rs delete mode 100644 node/src/chain_spec.rs delete mode 100644 node/src/cli.rs delete mode 100644 node/src/lib.rs delete mode 100644 node/src/main.rs delete mode 100644 node/src/rpc.rs delete mode 100644 node/src/service.rs diff --git a/Cargo.lock b/Cargo.lock index b22d474..87a29fd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -282,6 +282,26 @@ version = "0.7.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e22d1f4b888c298a027c99dc9048015fac177587de20fc30232a057dfbe24a21" +[[package]] +name = "assert_cmd" +version = "2.0.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9834fcc22e0874394a010230586367d4a3e9f11b560f469262678547e1d2575e" +dependencies = [ + "bstr", + "doc-comment", + "predicates", + "predicates-core", + "predicates-tree", + "wait-timeout", +] + +[[package]] +name = "assert_matches" +version = "1.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9" + [[package]] name = "async-io" version = "1.12.0" @@ -419,6 +439,16 @@ dependencies = [ "serde", ] +[[package]] +name = "beefy-merkle-tree" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "sp-api", + "sp-beefy", + "sp-runtime", +] + [[package]] name = "bincode" version = "1.3.3" @@ -577,6 +607,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b7f0778972c64420fdedc63f09919c8a88bda7b25135357fd25a5d9f3257e832" dependencies = [ "memchr", + "once_cell", + "regex-automata", "serde", ] @@ -661,6 +693,12 @@ dependencies = [ "serde_json", ] +[[package]] +name = "cast" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" + [[package]] name = "cc" version = "1.0.79" @@ -782,6 +820,15 @@ dependencies = [ "generic-array 0.14.6", ] +[[package]] +name = "ckb-merkle-mountain-range" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "56ccb671c5921be8a84686e6212ca184cb1d7c51cadcdbfcbd1cc3f042f5dfb8" +dependencies = [ + "cfg-if", +] + [[package]] name = "clang-sys" version = "1.4.0" @@ -793,6 +840,17 @@ dependencies = [ "libloading", ] +[[package]] +name = "clap" +version = "2.34.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c" +dependencies = [ + "bitflags", + "textwrap", + "unicode-width", +] + [[package]] name = "clap" version = "4.1.4" @@ -808,6 +866,15 @@ dependencies = [ "termcolor", ] +[[package]] +name = "clap_complete" +version = "4.1.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "501ff0a401473ea1d4c3b125ff95506b62c5bc5768d818634195fbb7c4ad5ff4" +dependencies = [ + "clap 4.1.4", +] + [[package]] name = "clap_derive" version = "4.1.0" @@ -1049,6 +1116,44 @@ dependencies = [ "cfg-if", ] +[[package]] +name = "criterion" +version = "0.3.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b01d6de93b2b6c65e17c634a26653a29d107b3c98c607c765bf38d041531cd8f" +dependencies = [ + "atty", + "cast", + "clap 2.34.0", + "criterion-plot", + "csv", + "futures", + "itertools", + "lazy_static", + "num-traits", + "oorandom", + "plotters", + "rayon", + "regex", + "serde", + "serde_cbor", + "serde_derive", + "serde_json", + "tinytemplate", + "tokio", + "walkdir", +] + +[[package]] +name = "criterion-plot" +version = "0.4.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876" +dependencies = [ + "cast", + "itertools", +] + [[package]] name = "crossbeam-channel" version = "0.5.6" @@ -1150,6 +1255,27 @@ dependencies = [ "subtle", ] +[[package]] +name = "csv" +version = "1.2.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0b015497079b9a9d69c02ad25de6c0a6edef051ea6360a327d0bd05802ef64ad" +dependencies = [ + "csv-core", + "itoa", + "ryu", + "serde", +] + +[[package]] +name = "csv-core" +version = "0.1.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90" +dependencies = [ + "memchr", +] + [[package]] name = "ctr" version = "0.6.0" @@ -1481,6 +1607,12 @@ dependencies = [ "syn", ] +[[package]] +name = "doc-comment" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10" + [[package]] name = "downcast" version = "0.11.0" @@ -1615,6 +1747,26 @@ dependencies = [ "syn", ] +[[package]] +name = "enumflags2" +version = "0.7.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e75d4cd21b95383444831539909fbb14b9dc3fdceb2a6f5d36577329a1f55ccb" +dependencies = [ + "enumflags2_derive", +] + +[[package]] +name = "enumflags2_derive" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f58dc3c5e468259f19f2d46304a6b28f1c3d034442e14b322d2b850e36f6d5ae" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + [[package]] name = "env_logger" version = "0.10.0" @@ -1852,7 +2004,7 @@ dependencies = [ "Inflector", "array-bytes", "chrono", - "clap", + "clap 4.1.4", "comfy-table", "frame-benchmarking", "frame-support", @@ -1891,6 +2043,34 @@ dependencies = [ "thousands", ] +[[package]] +name = "frame-election-provider-solution-type" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "frame-election-provider-support" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-election-provider-solution-type", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-arithmetic", + "sp-core", + "sp-npos-elections", + "sp-runtime", + "sp-std", +] + [[package]] name = "frame-executive" version = "4.0.0-dev" @@ -2068,6 +2248,12 @@ dependencies = [ "winapi", ] +[[package]] +name = "fs_extra" +version = "1.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c" + [[package]] name = "funty" version = "2.0.0" @@ -2342,6 +2528,12 @@ dependencies = [ "tracing", ] +[[package]] +name = "half" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7" + [[package]] name = "handlebars" version = "4.3.6" @@ -2416,12 +2608,6 @@ version = "0.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" -[[package]] -name = "hex-literal" -version = "0.3.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0" - [[package]] name = "hkdf" version = "0.12.3" @@ -2697,6 +2883,12 @@ dependencies = [ "serde", ] +[[package]] +name = "indexmap-nostd" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8e04e2fd2b8188ea827b32ef11de88377086d690286ab35747ef7f9bf3ccb590" + [[package]] name = "instant" version = "0.1.12" @@ -2964,6 +3156,102 @@ dependencies = [ "cpufeatures", ] +[[package]] +name = "kitchensink-runtime" +version = "3.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-election-provider-support", + "frame-executive", + "frame-support", + "frame-system", + "frame-system-benchmarking", + "frame-system-rpc-runtime-api", + "frame-try-runtime", + "log", + "node-primitives 2.0.0 (git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37)", + "pallet-alliance", + "pallet-asset-tx-payment", + "pallet-assets", + "pallet-authority-discovery", + "pallet-authorship", + "pallet-babe", + "pallet-bags-list", + "pallet-balances", + "pallet-bounties", + "pallet-child-bounties", + "pallet-collective", + "pallet-contracts", + "pallet-contracts-primitives", + "pallet-conviction-voting", + "pallet-democracy", + "pallet-election-provider-multi-phase", + "pallet-election-provider-support-benchmarking", + "pallet-elections-phragmen", + "pallet-fast-unstake", + "pallet-grandpa", + "pallet-identity", + "pallet-im-online", + "pallet-indices", + "pallet-lottery", + "pallet-membership", + "pallet-message-queue", + "pallet-mmr", + "pallet-multisig", + "pallet-nfts", + "pallet-nis", + "pallet-nomination-pools", + "pallet-nomination-pools-benchmarking", + "pallet-nomination-pools-runtime-api", + "pallet-offences", + "pallet-offences-benchmarking", + "pallet-preimage", + "pallet-proxy", + "pallet-randomness-collective-flip", + "pallet-ranked-collective", + "pallet-recovery", + "pallet-referenda", + "pallet-remark", + "pallet-root-testing", + "pallet-scheduler", + "pallet-session", + "pallet-session-benchmarking", + "pallet-society", + "pallet-staking", + "pallet-staking-reward-curve", + "pallet-state-trie-migration", + "pallet-sudo", + "pallet-timestamp", + "pallet-tips", + "pallet-transaction-payment", + "pallet-transaction-payment-rpc-runtime-api", + "pallet-transaction-storage", + "pallet-treasury", + "pallet-uniques", + "pallet-utility", + "pallet-vesting", + "pallet-whitelist", + "parity-scale-codec", + "scale-info", + "sp-api", + "sp-authority-discovery", + "sp-block-builder", + "sp-consensus-babe", + "sp-core", + "sp-inherents", + "sp-io", + "sp-offchain", + "sp-runtime", + "sp-session", + "sp-staking", + "sp-std", + "sp-transaction-pool", + "sp-version", + "static_assertions", + "substrate-wasm-builder", +] + [[package]] name = "kvdb" version = "0.13.0" @@ -3009,6 +3297,12 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55" +[[package]] +name = "leb128" +version = "0.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" + [[package]] name = "libc" version = "0.2.139" @@ -3765,6 +4059,22 @@ dependencies = [ "windows-sys 0.42.0", ] +[[package]] +name = "mmr-rpc" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "anyhow", + "jsonrpsee", + "parity-scale-codec", + "serde", + "sp-api", + "sp-blockchain", + "sp-core", + "sp-mmr-primitives", + "sp-runtime", +] + [[package]] name = "mockall" version = "0.11.3" @@ -3978,63 +4288,325 @@ dependencies = [ [[package]] name = "nix" -version = "0.24.3" +version = "0.23.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069" +checksum = "8f3790c00a0150112de0f4cd161e3d7fc4b2d8a5542ffc35f099a2562aecb35c" dependencies = [ "bitflags", + "cc", "cfg-if", "libc", "memoffset 0.6.5", ] [[package]] -name = "nohash-hasher" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451" - -[[package]] -name = "nom" -version = "7.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" -dependencies = [ - "memchr", - "minimal-lexical", -] - -[[package]] -name = "normalize-line-endings" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be" - -[[package]] -name = "num-bigint" -version = "0.4.3" +name = "nix" +version = "0.24.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f" +checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069" dependencies = [ - "autocfg", - "num-integer", - "num-traits", + "bitflags", + "cfg-if", + "libc", + "memoffset 0.6.5", ] [[package]] -name = "num-complex" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02e0d21255c828d6f128a1e41534206671e8c3ea0c62f32291e808dc82cff17d" +name = "node-cli" +version = "3.0.0-dev" dependencies = [ - "num-traits", -] - -[[package]] -name = "num-format" -version = "0.4.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a652d9771a63711fd3c3deb670acfbe5c30a4072e664d7a3bf5a9e1056ac72c3" + "array-bytes", + "assert_cmd", + "clap 4.1.4", + "clap_complete", + "criterion", + "frame-benchmarking-cli", + "frame-system", + "frame-system-rpc-runtime-api", + "futures", + "jsonrpsee", + "log", + "nix 0.23.2", + "node-executor 3.0.0-dev", + "node-inspect", + "node-primitives 2.0.0", + "node-rpc", + "pallet-asset-tx-payment", + "pallet-assets", + "pallet-balances", + "pallet-im-online", + "pallet-timestamp", + "pallet-transaction-payment", + "parity-scale-codec", + "platforms 2.0.0", + "rand 0.8.5", + "regex", + "sc-authority-discovery", + "sc-basic-authorship", + "sc-block-builder", + "sc-chain-spec", + "sc-cli", + "sc-client-api", + "sc-client-db", + "sc-consensus", + "sc-consensus-babe", + "sc-consensus-epochs", + "sc-consensus-slots", + "sc-consensus-uncles", + "sc-executor", + "sc-finality-grandpa", + "sc-keystore", + "sc-network", + "sc-network-common", + "sc-rpc", + "sc-service", + "sc-service-test", + "sc-sync-state-rpc", + "sc-sysinfo", + "sc-telemetry", + "sc-transaction-pool", + "sc-transaction-pool-api", + "serde", + "serde_json", + "soketto", + "sp-api", + "sp-authority-discovery", + "sp-authorship", + "sp-blockchain", + "sp-consensus", + "sp-consensus-babe", + "sp-core", + "sp-finality-grandpa", + "sp-inherents", + "sp-io", + "sp-keyring", + "sp-keystore", + "sp-runtime", + "sp-timestamp", + "sp-tracing", + "sp-transaction-pool", + "sp-transaction-storage-proof", + "substrate-build-script-utils", + "substrate-frame-cli", + "substrate-rpc-client", + "tempfile", + "tokio", + "tokio-util", + "try-runtime-cli", + "wait-timeout", + "xsocial-runtime", +] + +[[package]] +name = "node-executor" +version = "3.0.0-dev" +dependencies = [ + "criterion", + "frame-benchmarking", + "frame-support", + "frame-system", + "futures", + "node-primitives 2.0.0 (git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37)", + "node-testing", + "pallet-balances", + "pallet-contracts", + "pallet-im-online", + "pallet-root-testing", + "pallet-sudo", + "pallet-timestamp", + "pallet-transaction-payment", + "pallet-treasury", + "parity-scale-codec", + "sc-executor", + "scale-info", + "sp-application-crypto", + "sp-consensus-babe", + "sp-core", + "sp-externalities", + "sp-keyring", + "sp-keystore", + "sp-runtime", + "sp-state-machine", + "sp-tracing", + "sp-trie", + "wat", + "xsocial-runtime", +] + +[[package]] +name = "node-executor" +version = "3.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "kitchensink-runtime", + "node-primitives 2.0.0 (git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37)", + "parity-scale-codec", + "sc-executor", + "scale-info", + "sp-core", + "sp-keystore", + "sp-state-machine", + "sp-tracing", + "sp-trie", +] + +[[package]] +name = "node-inspect" +version = "0.9.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "clap 4.1.4", + "parity-scale-codec", + "sc-cli", + "sc-client-api", + "sc-executor", + "sc-service", + "sp-blockchain", + "sp-core", + "sp-runtime", + "thiserror", +] + +[[package]] +name = "node-primitives" +version = "2.0.0" +dependencies = [ + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-application-crypto", + "sp-core", + "sp-runtime", +] + +[[package]] +name = "node-primitives" +version = "2.0.0" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-application-crypto", + "sp-core", + "sp-runtime", +] + +[[package]] +name = "node-rpc" +version = "3.0.0-dev" +dependencies = [ + "jsonrpsee", + "mmr-rpc", + "node-primitives 2.0.0 (git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37)", + "pallet-transaction-payment-rpc", + "sc-chain-spec", + "sc-client-api", + "sc-consensus-babe", + "sc-consensus-babe-rpc", + "sc-consensus-epochs", + "sc-finality-grandpa", + "sc-finality-grandpa-rpc", + "sc-rpc", + "sc-rpc-api", + "sc-rpc-spec-v2", + "sc-sync-state-rpc", + "sc-transaction-pool-api", + "sp-api", + "sp-block-builder", + "sp-blockchain", + "sp-consensus", + "sp-consensus-babe", + "sp-keystore", + "sp-runtime", + "substrate-frame-rpc-system", + "substrate-state-trie-migration-rpc", +] + +[[package]] +name = "node-testing" +version = "3.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-system", + "fs_extra", + "futures", + "kitchensink-runtime", + "log", + "node-executor 3.0.0-dev (git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37)", + "node-primitives 2.0.0 (git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37)", + "pallet-asset-tx-payment", + "pallet-assets", + "pallet-transaction-payment", + "parity-scale-codec", + "sc-block-builder", + "sc-client-api", + "sc-client-db", + "sc-consensus", + "sc-executor", + "sc-service", + "sp-api", + "sp-block-builder", + "sp-blockchain", + "sp-consensus", + "sp-core", + "sp-inherents", + "sp-io", + "sp-keyring", + "sp-runtime", + "sp-timestamp", + "substrate-test-client", + "tempfile", +] + +[[package]] +name = "nohash-hasher" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451" + +[[package]] +name = "nom" +version = "7.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a" +dependencies = [ + "memchr", + "minimal-lexical", +] + +[[package]] +name = "normalize-line-endings" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "61807f77802ff30975e01f4f071c8ba10c022052f98b3294119f3e615d13e5be" + +[[package]] +name = "num-bigint" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + +[[package]] +name = "num-complex" +version = "0.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "02e0d21255c828d6f128a1e41534206671e8c3ea0c62f32291e808dc82cff17d" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-format" +version = "0.4.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a652d9771a63711fd3c3deb670acfbe5c30a4072e664d7a3bf5a9e1056ac72c3" dependencies = [ "arrayvec 0.7.2", "itoa", @@ -4127,6 +4699,12 @@ version = "1.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6f61fba1741ea2b3d6a1e3178721804bb716a68a6aeba1149b5d52e3d464ea66" +[[package]] +name = "oorandom" +version = "11.1.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575" + [[package]] name = "opaque-debug" version = "0.2.3" @@ -4184,37 +4762,105 @@ dependencies = [ ] [[package]] -name = "pallet-authorship" +name = "pallet-alliance" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ + "frame-benchmarking", "frame-support", "frame-system", - "impl-trait-for-tuples", + "log", + "pallet-collective", + "pallet-identity", "parity-scale-codec", "scale-info", - "sp-authorship", + "sp-core", + "sp-io", "sp-runtime", "sp-std", ] [[package]] -name = "pallet-babe" +name = "pallet-asset-tx-payment" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-benchmarking", "frame-support", "frame-system", - "log", - "pallet-authorship", - "pallet-session", - "pallet-timestamp", + "pallet-transaction-payment", "parity-scale-codec", "scale-info", - "sp-application-crypto", - "sp-consensus-babe", - "sp-consensus-vrf", + "serde", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-assets" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-authority-discovery" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-support", + "frame-system", + "pallet-session", + "parity-scale-codec", + "scale-info", + "sp-application-crypto", + "sp-authority-discovery", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-authorship" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-support", + "frame-system", + "impl-trait-for-tuples", + "parity-scale-codec", + "scale-info", + "sp-authorship", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-babe" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "pallet-authorship", + "pallet-session", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "sp-application-crypto", + "sp-consensus-babe", + "sp-consensus-vrf", "sp-io", "sp-runtime", "sp-session", @@ -4222,6 +4868,26 @@ dependencies = [ "sp-std", ] +[[package]] +name = "pallet-bags-list" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-election-provider-support", + "frame-support", + "frame-system", + "log", + "pallet-balances", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", + "sp-tracing", +] + [[package]] name = "pallet-balances" version = "4.0.0-dev" @@ -4237,6 +4903,43 @@ dependencies = [ "sp-std", ] +[[package]] +name = "pallet-bounties" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "pallet-treasury", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-child-bounties" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "pallet-bounties", + "pallet-treasury", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + [[package]] name = "pallet-collator-selection" version = "3.0.0" @@ -4257,179 +4960,939 @@ dependencies = [ ] [[package]] -name = "pallet-energy" -version = "0.1.7" -source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +name = "pallet-collective" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-benchmarking", "frame-support", "frame-system", - "pallet-transaction-payment", + "log", "parity-scale-codec", "scale-info", + "sp-core", + "sp-io", "sp-runtime", "sp-std", ] [[package]] -name = "pallet-grandpa" +name = "pallet-contracts" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ + "bitflags", "frame-benchmarking", "frame-support", "frame-system", + "impl-trait-for-tuples", "log", - "pallet-authorship", - "pallet-session", + "pallet-contracts-primitives", + "pallet-contracts-proc-macro", "parity-scale-codec", + "rand 0.8.5", "scale-info", - "sp-application-crypto", + "serde", + "smallvec", + "sp-api", "sp-core", - "sp-finality-grandpa", "sp-io", "sp-runtime", - "sp-session", - "sp-staking", "sp-std", + "wasm-instrument 0.4.0", + "wasmi 0.20.0", + "wasmparser-nostd", ] [[package]] -name = "pallet-permissions" -version = "0.1.7" -source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +name = "pallet-contracts-primitives" +version = "7.0.0" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "bitflags", + "parity-scale-codec", + "sp-runtime", + "sp-std", + "sp-weights", +] + +[[package]] +name = "pallet-contracts-proc-macro" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "pallet-conviction-voting" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ + "assert_matches", + "frame-benchmarking", "frame-support", "frame-system", "parity-scale-codec", "scale-info", "serde", + "sp-io", "sp-runtime", "sp-std", - "subsocial-support", ] [[package]] -name = "pallet-posts" -version = "0.1.7" -source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +name = "pallet-democracy" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-benchmarking", "frame-support", "frame-system", - "pallet-permissions", - "pallet-space-follows", - "pallet-spaces", - "pallet-timestamp", + "log", "parity-scale-codec", "scale-info", "serde", + "sp-core", + "sp-io", "sp-runtime", "sp-std", - "subsocial-support", ] [[package]] -name = "pallet-randomness-collective-flip" +name = "pallet-election-provider-multi-phase" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ + "frame-benchmarking", + "frame-election-provider-support", "frame-support", "frame-system", + "log", + "pallet-election-provider-support-benchmarking", "parity-scale-codec", - "safe-mix", + "rand 0.8.5", "scale-info", + "sp-arithmetic", + "sp-core", + "sp-io", + "sp-npos-elections", "sp-runtime", "sp-std", + "strum", ] [[package]] -name = "pallet-roles" +name = "pallet-election-provider-support-benchmarking" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-election-provider-support", + "frame-system", + "parity-scale-codec", + "sp-npos-elections", + "sp-runtime", +] + +[[package]] +name = "pallet-elections-phragmen" +version = "5.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-npos-elections", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-energy" version = "0.1.7" source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" dependencies = [ "frame-benchmarking", "frame-support", "frame-system", - "pallet-permissions", - "pallet-timestamp", + "pallet-transaction-payment", "parity-scale-codec", "scale-info", "sp-runtime", "sp-std", - "subsocial-support", ] [[package]] -name = "pallet-session" +name = "pallet-fast-unstake" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ + "frame-benchmarking", + "frame-election-provider-support", "frame-support", "frame-system", - "impl-trait-for-tuples", "log", - "pallet-timestamp", "parity-scale-codec", "scale-info", + "sp-io", + "sp-runtime", + "sp-staking", + "sp-std", +] + +[[package]] +name = "pallet-grandpa" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "pallet-authorship", + "pallet-session", + "parity-scale-codec", + "scale-info", + "sp-application-crypto", "sp-core", + "sp-finality-grandpa", "sp-io", "sp-runtime", "sp-session", "sp-staking", "sp-std", - "sp-trie", ] [[package]] -name = "pallet-space-follows" -version = "0.1.7" -source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +name = "pallet-identity" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "enumflags2", + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-im-online" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "pallet-authorship", + "parity-scale-codec", + "scale-info", + "sp-application-crypto", + "sp-core", + "sp-io", + "sp-runtime", + "sp-staking", + "sp-std", +] + +[[package]] +name = "pallet-indices" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-keyring", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-lottery" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-membership" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-message-queue" +version = "7.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-arithmetic", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", + "sp-weights", +] + +[[package]] +name = "pallet-mmr" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-mmr-primitives", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-multisig" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-nfts" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "enumflags2", + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-nis" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-arithmetic", + "sp-core", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-nomination-pools" +version = "1.0.0" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-staking", + "sp-std", +] + +[[package]] +name = "pallet-nomination-pools-benchmarking" +version = "1.0.0" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-election-provider-support", + "frame-support", + "frame-system", + "pallet-bags-list", + "pallet-nomination-pools", + "pallet-staking", + "parity-scale-codec", + "scale-info", + "sp-runtime", + "sp-runtime-interface", + "sp-staking", + "sp-std", +] + +[[package]] +name = "pallet-nomination-pools-runtime-api" +version = "1.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "parity-scale-codec", + "sp-api", + "sp-std", +] + +[[package]] +name = "pallet-offences" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-support", + "frame-system", + "log", + "pallet-balances", + "parity-scale-codec", + "scale-info", + "serde", + "sp-runtime", + "sp-staking", + "sp-std", +] + +[[package]] +name = "pallet-offences-benchmarking" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-election-provider-support", + "frame-support", + "frame-system", + "pallet-babe", + "pallet-balances", + "pallet-grandpa", + "pallet-im-online", + "pallet-offences", + "pallet-session", + "pallet-staking", + "parity-scale-codec", + "scale-info", + "sp-runtime", + "sp-staking", + "sp-std", +] + +[[package]] +name = "pallet-permissions" +version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +dependencies = [ + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "serde", + "sp-runtime", + "sp-std", + "subsocial-support", +] + +[[package]] +name = "pallet-posts" +version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "pallet-permissions", + "pallet-space-follows", + "pallet-spaces", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "serde", + "sp-runtime", + "sp-std", + "subsocial-support", +] + +[[package]] +name = "pallet-preimage" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-proxy" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-randomness-collective-flip" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-support", + "frame-system", + "parity-scale-codec", + "safe-mix", + "scale-info", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-ranked-collective" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-arithmetic", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-recovery" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-referenda" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "serde", + "sp-arithmetic", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-remark" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "serde", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-roles" +version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "pallet-permissions", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "sp-runtime", + "sp-std", + "subsocial-support", +] + +[[package]] +name = "pallet-root-testing" +version = "1.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-scheduler" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-io", + "sp-runtime", + "sp-std", + "sp-weights", +] + +[[package]] +name = "pallet-session" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-support", + "frame-system", + "impl-trait-for-tuples", + "log", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-session", + "sp-staking", + "sp-std", + "sp-trie", +] + +[[package]] +name = "pallet-session-benchmarking" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "pallet-session", + "pallet-staking", + "rand 0.8.5", + "sp-runtime", + "sp-session", + "sp-std", +] + +[[package]] +name = "pallet-society" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-support", + "frame-system", + "parity-scale-codec", + "rand_chacha 0.2.2", + "scale-info", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-space-follows" +version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "pallet-spaces", + "parity-scale-codec", + "scale-info", + "sp-std", + "subsocial-support", +] + +[[package]] +name = "pallet-spaces" +version = "0.1.7" +source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "impl-trait-for-tuples", + "pallet-permissions", + "pallet-timestamp", + "parity-scale-codec", + "scale-info", + "sp-runtime", + "sp-std", + "subsocial-support", +] + +[[package]] +name = "pallet-staking" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-election-provider-support", + "frame-support", + "frame-system", + "log", + "pallet-authorship", + "pallet-session", + "parity-scale-codec", + "scale-info", + "serde", + "sp-application-crypto", + "sp-io", + "sp-runtime", + "sp-staking", + "sp-std", +] + +[[package]] +name = "pallet-staking-reward-curve" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "pallet-state-trie-migration" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-sudo" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-timestamp" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "parity-scale-codec", + "scale-info", + "sp-inherents", + "sp-io", + "sp-runtime", + "sp-std", + "sp-timestamp", +] + +[[package]] +name = "pallet-tips" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-benchmarking", + "frame-support", + "frame-system", + "log", + "pallet-treasury", + "parity-scale-codec", + "scale-info", + "serde", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-transaction-payment" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "frame-support", + "frame-system", + "parity-scale-codec", + "scale-info", + "serde", + "sp-core", + "sp-io", + "sp-runtime", + "sp-std", +] + +[[package]] +name = "pallet-transaction-payment-rpc" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "jsonrpsee", + "pallet-transaction-payment-rpc-runtime-api", + "parity-scale-codec", + "sp-api", + "sp-blockchain", + "sp-core", + "sp-rpc", + "sp-runtime", + "sp-weights", +] + +[[package]] +name = "pallet-transaction-payment-rpc-runtime-api" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ - "frame-benchmarking", - "frame-support", - "frame-system", - "pallet-spaces", + "pallet-transaction-payment", "parity-scale-codec", - "scale-info", - "sp-std", - "subsocial-support", + "sp-api", + "sp-runtime", + "sp-weights", ] [[package]] -name = "pallet-spaces" -version = "0.1.7" -source = "git+https://github.com/dappforce/subsocial-parachain.git?rev=035c651a03ba94d78f1d5dbc87a5f4461cfbb664#035c651a03ba94d78f1d5dbc87a5f4461cfbb664" +name = "pallet-transaction-storage" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ "frame-benchmarking", "frame-support", "frame-system", - "impl-trait-for-tuples", - "pallet-permissions", - "pallet-timestamp", + "log", + "pallet-balances", "parity-scale-codec", "scale-info", + "serde", + "sp-inherents", + "sp-io", "sp-runtime", "sp-std", - "subsocial-support", + "sp-transaction-storage-proof", ] [[package]] -name = "pallet-sudo" +name = "pallet-treasury" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ + "frame-benchmarking", "frame-support", "frame-system", + "impl-trait-for-tuples", + "pallet-balances", "parity-scale-codec", "scale-info", - "sp-io", + "serde", "sp-runtime", "sp-std", ] [[package]] -name = "pallet-timestamp" +name = "pallet-uniques" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ @@ -4439,23 +5902,20 @@ dependencies = [ "log", "parity-scale-codec", "scale-info", - "sp-inherents", - "sp-io", "sp-runtime", "sp-std", - "sp-timestamp", ] [[package]] -name = "pallet-transaction-payment" +name = "pallet-utility" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ + "frame-benchmarking", "frame-support", "frame-system", "parity-scale-codec", "scale-info", - "serde", "sp-core", "sp-io", "sp-runtime", @@ -4463,31 +5923,33 @@ dependencies = [ ] [[package]] -name = "pallet-transaction-payment-rpc" +name = "pallet-vesting" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ - "jsonrpsee", - "pallet-transaction-payment-rpc-runtime-api", + "frame-benchmarking", + "frame-support", + "frame-system", + "log", "parity-scale-codec", - "sp-api", - "sp-blockchain", - "sp-core", - "sp-rpc", + "scale-info", "sp-runtime", - "sp-weights", + "sp-std", ] [[package]] -name = "pallet-transaction-payment-rpc-runtime-api" +name = "pallet-whitelist" version = "4.0.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ - "pallet-transaction-payment", + "frame-benchmarking", + "frame-support", + "frame-system", "parity-scale-codec", + "scale-info", "sp-api", "sp-runtime", - "sp-weights", + "sp-std", ] [[package]] @@ -4776,6 +6238,34 @@ version = "3.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e3d7ddaed09e0eb771a79ab0fd64609ba0afb0a8366421957936ad14cbd13630" +[[package]] +name = "plotters" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2538b639e642295546c50fcd545198c9d64ee2a38620a628724a3b266d5fbf97" +dependencies = [ + "num-traits", + "plotters-backend", + "plotters-svg", + "wasm-bindgen", + "web-sys", +] + +[[package]] +name = "plotters-backend" +version = "0.3.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "193228616381fecdc1224c62e96946dfbc73ff4384fba576e052ff8c1bea8142" + +[[package]] +name = "plotters-svg" +version = "0.3.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f9a81d2759aae1dae668f783c308bc5c8ebd191ff4184aaa1b37f65a6ae5a56f" +dependencies = [ + "plotters-backend", +] + [[package]] name = "polling" version = "2.5.2" @@ -5350,7 +6840,7 @@ dependencies = [ "cc", "libc", "once_cell", - "spin", + "spin 0.5.2", "untrusted", "web-sys", "winapi", @@ -5398,7 +6888,7 @@ dependencies = [ "log", "netlink-packet-route", "netlink-proto", - "nix", + "nix 0.24.3", "thiserror", "tokio", ] @@ -5598,6 +7088,33 @@ dependencies = [ "thiserror", ] +[[package]] +name = "sc-authority-discovery" +version = "0.10.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "async-trait", + "futures", + "futures-timer", + "ip_network", + "libp2p", + "log", + "parity-scale-codec", + "prost", + "prost-build", + "rand 0.8.5", + "sc-client-api", + "sc-network-common", + "sp-api", + "sp-authority-discovery", + "sp-blockchain", + "sp-core", + "sp-keystore", + "sp-runtime", + "substrate-prometheus-endpoint", + "thiserror", +] + [[package]] name = "sc-basic-authorship" version = "0.10.0-dev" @@ -5670,7 +7187,7 @@ source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.3 dependencies = [ "array-bytes", "chrono", - "clap", + "clap 4.1.4", "fdlimit", "futures", "libp2p", @@ -5817,6 +7334,28 @@ dependencies = [ "thiserror", ] +[[package]] +name = "sc-consensus-babe-rpc" +version = "0.10.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "futures", + "jsonrpsee", + "sc-consensus-babe", + "sc-consensus-epochs", + "sc-rpc-api", + "serde", + "sp-api", + "sp-application-crypto", + "sp-blockchain", + "sp-consensus", + "sp-consensus-babe", + "sp-core", + "sp-keystore", + "sp-runtime", + "thiserror", +] + [[package]] name = "sc-consensus-epochs" version = "0.10.0-dev" @@ -5853,6 +7392,17 @@ dependencies = [ "sp-state-machine", ] +[[package]] +name = "sc-consensus-uncles" +version = "0.10.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "sc-client-api", + "sp-authorship", + "sp-runtime", + "thiserror", +] + [[package]] name = "sc-executor" version = "0.10.0-dev" @@ -5874,7 +7424,7 @@ dependencies = [ "sp-version", "sp-wasm-interface", "tracing", - "wasmi", + "wasmi 0.13.2", ] [[package]] @@ -5886,8 +7436,8 @@ dependencies = [ "sp-maybe-compressed-blob", "sp-wasm-interface", "thiserror", - "wasm-instrument", - "wasmi", + "wasm-instrument 0.3.0", + "wasmi 0.13.2", ] [[package]] @@ -5900,7 +7450,7 @@ dependencies = [ "sc-executor-common", "sp-runtime-interface", "sp-wasm-interface", - "wasmi", + "wasmi 0.13.2", ] [[package]] @@ -5960,6 +7510,26 @@ dependencies = [ "thiserror", ] +[[package]] +name = "sc-finality-grandpa-rpc" +version = "0.10.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "finality-grandpa", + "futures", + "jsonrpsee", + "log", + "parity-scale-codec", + "sc-client-api", + "sc-finality-grandpa", + "sc-rpc", + "serde", + "sp-blockchain", + "sp-core", + "sp-runtime", + "thiserror", +] + [[package]] name = "sc-informant" version = "0.10.0-dev" @@ -6373,6 +7943,42 @@ dependencies = [ "tracing-futures", ] +[[package]] +name = "sc-service-test" +version = "2.0.0" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "array-bytes", + "fdlimit", + "futures", + "log", + "parity-scale-codec", + "parking_lot 0.12.1", + "sc-block-builder", + "sc-client-api", + "sc-client-db", + "sc-consensus", + "sc-executor", + "sc-network", + "sc-network-common", + "sc-service", + "sc-transaction-pool-api", + "sp-api", + "sp-blockchain", + "sp-consensus", + "sp-core", + "sp-io", + "sp-runtime", + "sp-state-machine", + "sp-storage", + "sp-tracing", + "sp-trie", + "substrate-test-runtime", + "substrate-test-runtime-client", + "tempfile", + "tokio", +] + [[package]] name = "sc-state-db" version = "0.10.0-dev" @@ -6384,6 +7990,25 @@ dependencies = [ "sp-core", ] +[[package]] +name = "sc-sync-state-rpc" +version = "0.10.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "jsonrpsee", + "parity-scale-codec", + "sc-chain-spec", + "sc-client-api", + "sc-consensus-babe", + "sc-consensus-epochs", + "sc-finality-grandpa", + "serde", + "serde_json", + "sp-blockchain", + "sp-runtime", + "thiserror", +] + [[package]] name = "sc-sysinfo" version = "6.0.0-dev" @@ -6721,6 +8346,16 @@ dependencies = [ "serde_derive", ] +[[package]] +name = "serde_cbor" +version = "0.11.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5" +dependencies = [ + "half", + "serde", +] + [[package]] name = "serde_derive" version = "1.0.152" @@ -6976,6 +8611,19 @@ dependencies = [ "static_assertions", ] +[[package]] +name = "sp-authority-discovery" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "parity-scale-codec", + "scale-info", + "sp-api", + "sp-application-crypto", + "sp-runtime", + "sp-std", +] + [[package]] name = "sp-authorship" version = "4.0.0-dev" @@ -6988,6 +8636,23 @@ dependencies = [ "sp-std", ] +[[package]] +name = "sp-beefy" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "parity-scale-codec", + "scale-info", + "serde", + "sp-api", + "sp-application-crypto", + "sp-core", + "sp-io", + "sp-mmr-primitives", + "sp-runtime", + "sp-std", +] + [[package]] name = "sp-block-builder" version = "4.0.0-dev" @@ -7030,10 +8695,28 @@ dependencies = [ "sp-core", "sp-inherents", "sp-runtime", - "sp-state-machine", + "sp-state-machine", + "sp-std", + "sp-version", + "thiserror", +] + +[[package]] +name = "sp-consensus-aura" +version = "0.10.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "async-trait", + "parity-scale-codec", + "scale-info", + "sp-api", + "sp-application-crypto", + "sp-consensus", + "sp-consensus-slots", + "sp-inherents", + "sp-runtime", "sp-std", - "sp-version", - "thiserror", + "sp-timestamp", ] [[package]] @@ -7275,6 +8958,38 @@ dependencies = [ "zstd", ] +[[package]] +name = "sp-mmr-primitives" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "ckb-merkle-mountain-range", + "log", + "parity-scale-codec", + "scale-info", + "serde", + "sp-api", + "sp-core", + "sp-debug-derive", + "sp-runtime", + "sp-std", + "thiserror", +] + +[[package]] +name = "sp-npos-elections" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "parity-scale-codec", + "scale-info", + "serde", + "sp-arithmetic", + "sp-core", + "sp-runtime", + "sp-std", +] + [[package]] name = "sp-offchain" version = "4.0.0-dev" @@ -7533,7 +9248,7 @@ dependencies = [ "log", "parity-scale-codec", "sp-std", - "wasmi", + "wasmi 0.13.2", "wasmtime", ] @@ -7558,6 +9273,12 @@ version = "0.5.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" +[[package]] +name = "spin" +version = "0.9.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b5d6e0250b93c8427a177b849d144a96d5acc57006149479403d7861ab721e34" + [[package]] name = "spki" version = "0.6.0" @@ -7718,6 +9439,19 @@ dependencies = [ "platforms 2.0.0", ] +[[package]] +name = "substrate-frame-cli" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "clap 4.1.4", + "frame-support", + "frame-system", + "sc-cli", + "sp-core", + "sp-runtime", +] + [[package]] name = "substrate-frame-rpc-system" version = "4.0.0-dev" @@ -7762,6 +9496,113 @@ dependencies = [ "sp-runtime", ] +[[package]] +name = "substrate-state-trie-migration-rpc" +version = "4.0.0-dev" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "jsonrpsee", + "log", + "parity-scale-codec", + "sc-client-api", + "sc-rpc-api", + "scale-info", + "serde", + "sp-core", + "sp-runtime", + "sp-state-machine", + "sp-trie", + "trie-db", +] + +[[package]] +name = "substrate-test-client" +version = "2.0.1" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "array-bytes", + "async-trait", + "futures", + "parity-scale-codec", + "sc-client-api", + "sc-client-db", + "sc-consensus", + "sc-executor", + "sc-offchain", + "sc-service", + "serde", + "serde_json", + "sp-blockchain", + "sp-consensus", + "sp-core", + "sp-keyring", + "sp-keystore", + "sp-runtime", + "sp-state-machine", +] + +[[package]] +name = "substrate-test-runtime" +version = "2.0.0" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "beefy-merkle-tree", + "cfg-if", + "frame-support", + "frame-system", + "frame-system-rpc-runtime-api", + "log", + "memory-db", + "pallet-babe", + "pallet-timestamp", + "parity-scale-codec", + "sc-service", + "scale-info", + "serde", + "sp-api", + "sp-application-crypto", + "sp-beefy", + "sp-block-builder", + "sp-consensus-aura", + "sp-consensus-babe", + "sp-core", + "sp-externalities", + "sp-finality-grandpa", + "sp-inherents", + "sp-io", + "sp-keyring", + "sp-offchain", + "sp-runtime", + "sp-runtime-interface", + "sp-session", + "sp-state-machine", + "sp-std", + "sp-transaction-pool", + "sp-trie", + "sp-version", + "substrate-wasm-builder", + "trie-db", +] + +[[package]] +name = "substrate-test-runtime-client" +version = "2.0.0" +source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" +dependencies = [ + "futures", + "parity-scale-codec", + "sc-block-builder", + "sc-client-api", + "sc-consensus", + "sp-api", + "sp-blockchain", + "sp-consensus", + "sp-core", + "sp-runtime", + "substrate-test-client", + "substrate-test-runtime", +] + [[package]] name = "substrate-wasm-builder" version = "5.0.0-dev" @@ -7879,6 +9720,15 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "95059e91184749cb66be6dc994f67f182b6d897cb3df74a5bf66b5e709295fd8" +[[package]] +name = "textwrap" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060" +dependencies = [ + "unicode-width", +] + [[package]] name = "thiserror" version = "1.0.38" @@ -8301,7 +10151,7 @@ name = "try-runtime-cli" version = "0.10.0-dev" source = "git+https://github.com/paritytech/substrate.git?branch=polkadot-v0.9.37#f38bd6671d460293c93062cc1e4fe9e9e490cb29" dependencies = [ - "clap", + "clap 4.1.4", "frame-remote-externalities", "frame-try-runtime", "hex", @@ -8493,6 +10343,15 @@ version = "1.0.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d" +[[package]] +name = "wait-timeout" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6" +dependencies = [ + "libc", +] + [[package]] name = "waitgroup" version = "0.1.2" @@ -8613,6 +10472,15 @@ version = "0.2.84" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d" +[[package]] +name = "wasm-encoder" +version = "0.25.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4eff853c4f09eec94d76af527eddad4e9de13b11d6286a1ef7134bc30135a2b7" +dependencies = [ + "leb128", +] + [[package]] name = "wasm-instrument" version = "0.3.0" @@ -8622,6 +10490,15 @@ dependencies = [ "parity-wasm", ] +[[package]] +name = "wasm-instrument" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a47ecb37b9734d1085eaa5ae1a81e60801fd8c28d4cabdd8aedb982021918bc" +dependencies = [ + "parity-wasm", +] + [[package]] name = "wasm-opt" version = "0.110.2" @@ -8686,7 +10563,19 @@ checksum = "06c326c93fbf86419608361a2c925a31754cf109da1b8b55737070b4d6669422" dependencies = [ "parity-wasm", "wasmi-validation", - "wasmi_core", + "wasmi_core 0.2.1", +] + +[[package]] +name = "wasmi" +version = "0.20.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "01bf50edb2ea9d922aa75a7bf3c15e26a6c9e2d18c56e862b49737a582901729" +dependencies = [ + "spin 0.9.6", + "wasmi_arena", + "wasmi_core 0.5.0", + "wasmparser-nostd", ] [[package]] @@ -8698,6 +10587,12 @@ dependencies = [ "parity-wasm", ] +[[package]] +name = "wasmi_arena" +version = "0.1.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a1ea379cbb0b41f3a9f0bf7b47036d036aae7f43383d8cc487d4deccf40dee0a" + [[package]] name = "wasmi_core" version = "0.2.1" @@ -8711,6 +10606,17 @@ dependencies = [ "num-traits", ] +[[package]] +name = "wasmi_core" +version = "0.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c5bf998ab792be85e20e771fe14182b4295571ad1d4f89d3da521c1bef5f597a" +dependencies = [ + "downcast-rs", + "libm 0.2.6", + "num-traits", +] + [[package]] name = "wasmparser" version = "0.89.1" @@ -8720,6 +10626,15 @@ dependencies = [ "indexmap", ] +[[package]] +name = "wasmparser-nostd" +version = "0.91.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9c37f310b5a62bfd5ae7c0f1d8e6f98af16a5d6d84ba764e9c36439ec14e318b" +dependencies = [ + "indexmap-nostd", +] + [[package]] name = "wasmtime" version = "1.0.2" @@ -8890,6 +10805,27 @@ dependencies = [ "wasmparser", ] +[[package]] +name = "wast" +version = "55.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4984d3e1406571f4930ba5cf79bd70f75f41d0e87e17506e0bd19b0e5d085f05" +dependencies = [ + "leb128", + "memchr", + "unicode-width", + "wasm-encoder", +] + +[[package]] +name = "wat" +version = "1.0.61" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "af2b53f4da14db05d32e70e9c617abdf6620c575bd5dd972b7400037b4df2091" +dependencies = [ + "wast", +] + [[package]] name = "web-sys" version = "0.3.61" @@ -9134,7 +11070,7 @@ dependencies = [ "lazy_static", "libc", "log", - "nix", + "nix 0.24.3", "rand 0.8.5", "thiserror", "tokio", @@ -9442,52 +11378,6 @@ dependencies = [ "time 0.3.17", ] -[[package]] -name = "xsocial-node" -version = "4.0.0-dev" -dependencies = [ - "clap", - "frame-benchmarking", - "frame-benchmarking-cli", - "frame-system", - "futures", - "hex-literal", - "jsonrpsee", - "pallet-transaction-payment", - "pallet-transaction-payment-rpc", - "sc-basic-authorship", - "sc-chain-spec", - "sc-cli", - "sc-client-api", - "sc-consensus", - "sc-consensus-babe", - "sc-executor", - "sc-finality-grandpa", - "sc-keystore", - "sc-rpc", - "sc-rpc-api", - "sc-service", - "sc-telemetry", - "sc-transaction-pool", - "sc-transaction-pool-api", - "sp-api", - "sp-block-builder", - "sp-blockchain", - "sp-consensus", - "sp-consensus-babe", - "sp-core", - "sp-finality-grandpa", - "sp-inherents", - "sp-io", - "sp-keyring", - "sp-runtime", - "sp-timestamp", - "substrate-build-script-utils", - "substrate-frame-rpc-system", - "try-runtime-cli", - "xsocial-runtime", -] - [[package]] name = "xsocial-runtime" version = "4.0.0-dev" diff --git a/Cargo.toml b/Cargo.toml index 1997451..788e15d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,9 @@ [workspace] members = [ - "node", + "node/cli", + "node/executor", + "node/primitives", + "node/rpc", # "pallets/*", "runtime", ] diff --git a/node/Cargo.toml b/node/Cargo.toml deleted file mode 100644 index 2eb87f6..0000000 --- a/node/Cargo.toml +++ /dev/null @@ -1,81 +0,0 @@ -[package] -name = "xsocial-node" -version = "4.0.0-dev" -description = "A fresh FRAME-based Substrate node, ready for hacking." -authors = ["Substrate DevHub "] -homepage = "https://substrate.io/" -edition = "2021" -publish = false -repository = "https://github.com/dappforce/xsocial-testnet/" -build = "build.rs" - -[package.metadata.docs.rs] -targets = ["x86_64-unknown-linux-gnu"] - -[[bin]] -name = "xsocial-node" - -[dependencies] -clap = { version = "4.0.9", features = ["derive"] } -futures = { version = "0.3.21", features = ["thread-pool"]} -hex-literal = "0.3.4" - -sc-chain-spec = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-cli = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-core = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-executor = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-service = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-telemetry = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-keystore = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-transaction-pool = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-transaction-pool-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-consensus-babe = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-consensus-babe = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-consensus = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-consensus = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-finality-grandpa = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-finality-grandpa = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-client-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-runtime = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-io = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-timestamp = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-inherents = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-keyring = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -frame-system = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } - -# These dependencies are used for the node's RPCs -jsonrpsee = { version = "0.16.2", features = ["server"] } -sc-rpc = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-rpc-api = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-blockchain = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sp-block-builder = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -sc-basic-authorship = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -substrate-frame-rpc-system = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -pallet-transaction-payment-rpc = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } - -# These dependencies are used for runtime benchmarking -frame-benchmarking = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -frame-benchmarking-cli = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } - -# Local Dependencies -xsocial-runtime = { version = "4.0.0-dev", path = "../runtime" } - -# CLI-specific dependencies -try-runtime-cli = { version = "0.10.0-dev", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } - -[build-dependencies] -substrate-build-script-utils = { version = "3.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } - -[features] -default = [] -# Dependencies that are only required if runtime benchmarking should be build. -runtime-benchmarks = [ - "xsocial-runtime/runtime-benchmarks", - "frame-benchmarking/runtime-benchmarks", - "frame-benchmarking-cli/runtime-benchmarks", -] -# Enable features that allow the runtime to be tried and debugged. Name might be subject to change -# in the near future. -try-runtime = ["xsocial-runtime/try-runtime", "try-runtime-cli/try-runtime"] diff --git a/node/build.rs b/node/build.rs deleted file mode 100644 index e3bfe31..0000000 --- a/node/build.rs +++ /dev/null @@ -1,7 +0,0 @@ -use substrate_build_script_utils::{generate_cargo_keys, rerun_if_git_head_changed}; - -fn main() { - generate_cargo_keys(); - - rerun_if_git_head_changed(); -} diff --git a/node/cli/Cargo.toml b/node/cli/Cargo.toml new file mode 100644 index 0000000..3bfd079 --- /dev/null +++ b/node/cli/Cargo.toml @@ -0,0 +1,160 @@ +[package] +name = "node-cli" +version = "3.0.0-dev" +authors = ["Parity Technologies "] +description = "Generic Substrate node implementation in Rust." +build = "build.rs" +edition = "2021" +license = "GPL-3.0-or-later WITH Classpath-exception-2.0" +default-run = "substrate" +homepage = "https://substrate.io" +repository = "https://github.com/paritytech/substrate/" +publish = false + +[package.metadata.wasm-pack.profile.release] +# `wasm-opt` has some problems on linux, see +# https://github.com/rustwasm/wasm-pack/issues/781 etc. +wasm-opt = false + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[badges] +travis-ci = { repository = "paritytech/substrate" } +maintenance = { status = "actively-developed" } +is-it-maintained-issue-resolution = { repository = "paritytech/substrate" } +is-it-maintained-open-issues = { repository = "paritytech/substrate" } + +[[bin]] +name = "substrate" +path = "bin/main.rs" +required-features = ["cli"] + +[lib] +crate-type = ["cdylib", "rlib"] + +[dependencies] +# third-party dependencies +array-bytes = "4.1" +clap = { version = "4.0.9", features = ["derive"], optional = true } +codec = { package = "parity-scale-codec", version = "3.0.0" } +serde = { version = "1.0.136", features = ["derive"] } +jsonrpsee = { version = "0.16.2", features = ["server"] } +futures = "0.3.21" +log = "0.4.17" +rand = "0.8" + +# primitives +sp-authority-discovery = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-consensus-babe = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +grandpa-primitives = { version = "4.0.0-dev", package = "sp-finality-grandpa", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-core = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-runtime = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-timestamp = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-authorship = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-inherents = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-keyring = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-keystore = { version = "0.13.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-consensus = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-transaction-pool = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-transaction-storage-proof = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-io = { git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } + +# client dependencies +sc-client-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-chain-spec = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-transaction-pool = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-transaction-pool-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-network = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-network-common = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus-slots = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus-babe = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus-uncles = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +grandpa = { version = "0.10.0-dev", package = "sc-finality-grandpa", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-rpc = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-basic-authorship = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-service = { version = "0.10.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-telemetry = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-executor = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-authority-discovery = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-sync-state-rpc = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-sysinfo = { version = "6.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } + +# frame dependencies +frame-system = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +frame-system-rpc-runtime-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-transaction-payment = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-assets = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-asset-tx-payment = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-im-online = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } + +# node-specific dependencies +xsocial-runtime = { path = "../../runtime" } +node-rpc = { path = "../rpc" } +node-primitives = { path = "../primitives" } +node-executor = { path = "../executor" } + +# CLI-specific dependencies +sc-cli = { version = "0.10.0-dev", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +frame-benchmarking-cli = { version = "4.0.0-dev", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +node-inspect = { version = "0.9.0-dev", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +try-runtime-cli = { version = "0.10.0-dev", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +serde_json = "1.0.85" + +[dev-dependencies] +sc-keystore = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-client-db = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus-babe = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus-epochs = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-service-test = { version = "2.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-block-builder = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-tracing = { version = "6.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-blockchain = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +futures = "0.3.21" +tempfile = "3.1.0" +assert_cmd = "2.0.2" +nix = "0.23" +serde_json = "1.0" +regex = "1.6.0" +platforms = "2.0" +soketto = "0.7.1" +criterion = { version = "0.3.5", features = ["async_tokio"] } +tokio = { version = "1.22.0", features = ["macros", "time", "parking_lot"] } +tokio-util = { version = "0.7.4", features = ["compat"] } +wait-timeout = "0.2" +substrate-rpc-client = { git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-timestamp = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } + +[build-dependencies] +clap = { version = "4.0.9", optional = true } +clap_complete = { version = "4.0.2", optional = true } +node-inspect = { version = "0.9.0-dev", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +frame-benchmarking-cli = { version = "4.0.0-dev", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +substrate-build-script-utils = { version = "3.0.0", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +substrate-frame-cli = { version = "4.0.0-dev", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +try-runtime-cli = { version = "0.10.0-dev", optional = true, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-cli = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37", optional = true } +pallet-balances = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } + +[features] +default = ["cli"] +cli = [ + "node-inspect", + "sc-cli", + "frame-benchmarking-cli", + "substrate-frame-cli", + "sc-service/rocksdb", + "clap", + "clap_complete", + "substrate-build-script-utils", + "try-runtime-cli", +] +runtime-benchmarks = [ + "frame-benchmarking-cli/runtime-benchmarks" +] +# Enable features that allow the runtime to be tried and debugged. Name might be subject to change +# in the near future. +try-runtime = ["xsocial-runtime/try-runtime", "try-runtime-cli/try-runtime"] diff --git a/node/cli/bin/main.rs b/node/cli/bin/main.rs new file mode 100644 index 0000000..3ae2957 --- /dev/null +++ b/node/cli/bin/main.rs @@ -0,0 +1,25 @@ +// This file is part of Substrate. + +// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Substrate Node CLI + +#![warn(missing_docs)] + +fn main() -> sc_cli::Result<()> { + node_cli::run() +} diff --git a/node/cli/build.rs b/node/cli/build.rs new file mode 100644 index 0000000..e8142b2 --- /dev/null +++ b/node/cli/build.rs @@ -0,0 +1,66 @@ +// This file is part of Substrate. + +// Copyright (C) 2017-2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +fn main() { + #[cfg(feature = "cli")] + cli::main(); +} + +#[cfg(feature = "cli")] +mod cli { + include!("src/cli.rs"); + + use clap::{CommandFactory, ValueEnum}; + use clap_complete::{generate_to, Shell}; + use std::{env, fs, path::Path}; + use substrate_build_script_utils::{generate_cargo_keys, rerun_if_git_head_changed}; + + pub fn main() { + build_shell_completion(); + generate_cargo_keys(); + + rerun_if_git_head_changed(); + } + + /// Build shell completion scripts for all known shells + fn build_shell_completion() { + for shell in Shell::value_variants() { + build_completion(shell); + } + } + + /// Build the shell auto-completion for a given Shell + fn build_completion(shell: &Shell) { + let outdir = match env::var_os("OUT_DIR") { + None => return, + Some(dir) => dir, + }; + let path = Path::new(&outdir) + .parent() + .unwrap() + .parent() + .unwrap() + .parent() + .unwrap() + .join("completion-scripts"); + + fs::create_dir(&path).ok(); + + let _ = generate_to(*shell, &mut Cli::command(), "substrate-node", &path); + } +} diff --git a/node/src/benchmarking.rs b/node/cli/src/benchmarking.rs similarity index 50% rename from node/src/benchmarking.rs rename to node/cli/src/benchmarking.rs index 15bf9d3..31514e3 100644 --- a/node/src/benchmarking.rs +++ b/node/cli/src/benchmarking.rs @@ -1,21 +1,37 @@ +// This file is part of Substrate. + +// Copyright (C) 2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + //! Setup code for [`super::command`] which would otherwise bloat that module. //! //! Should only be used for benchmarking as it may break in other contexts. -use crate::service::FullClient; +use crate::service::{create_extrinsic, FullClient}; -use xsocial_runtime as runtime; -use runtime::{AccountId, Balance, BalancesCall, SystemCall}; +use xsocial_runtime::{BalancesCall, SystemCall}; +use node_primitives::{AccountId, Balance}; use sc_cli::Result; -use sc_client_api::BlockBackend; -use sp_core::{Encode, Pair}; use sp_inherents::{InherentData, InherentDataProvider}; use sp_keyring::Sr25519Keyring; -use sp_runtime::{OpaqueExtrinsic, SaturatedConversion}; +use sp_runtime::OpaqueExtrinsic; use std::{sync::Arc, time::Duration}; -/// Generates extrinsics for the `benchmark overhead` command. +/// Generates `System::Remark` extrinsics for the benchmarks. /// /// Note: Should only be used for benchmarking. pub struct RemarkBuilder { @@ -40,11 +56,11 @@ impl frame_benchmarking_cli::ExtrinsicBuilder for RemarkBuilder { fn build(&self, nonce: u32) -> std::result::Result { let acc = Sr25519Keyring::Bob.pair(); - let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic( + let extrinsic: OpaqueExtrinsic = create_extrinsic( self.client.as_ref(), acc, - SystemCall::remark { remark: vec![] }.into(), - nonce, + SystemCall::remark { remark: vec![] }, + Some(nonce), ) .into(); @@ -79,15 +95,14 @@ impl frame_benchmarking_cli::ExtrinsicBuilder for TransferKeepAliveBuilder { fn build(&self, nonce: u32) -> std::result::Result { let acc = Sr25519Keyring::Bob.pair(); - let extrinsic: OpaqueExtrinsic = create_benchmark_extrinsic( + let extrinsic: OpaqueExtrinsic = create_extrinsic( self.client.as_ref(), acc, BalancesCall::transfer_keep_alive { dest: self.dest.clone().into(), value: self.value.into(), - } - .into(), - nonce, + }, + Some(nonce), ) .into(); @@ -95,64 +110,7 @@ impl frame_benchmarking_cli::ExtrinsicBuilder for TransferKeepAliveBuilder { } } -/// Create a transaction using the given `call`. -/// -/// Note: Should only be used for benchmarking. -pub fn create_benchmark_extrinsic( - client: &FullClient, - sender: sp_core::sr25519::Pair, - call: runtime::RuntimeCall, - nonce: u32, -) -> runtime::UncheckedExtrinsic { - let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"); - let best_hash = client.chain_info().best_hash; - let best_block = client.chain_info().best_number; - - let period = runtime::BlockHashCount::get() - .checked_next_power_of_two() - .map(|c| c / 2) - .unwrap_or(2) as u64; - let extra: runtime::SignedExtra = ( - frame_system::CheckNonZeroSender::::new(), - frame_system::CheckSpecVersion::::new(), - frame_system::CheckTxVersion::::new(), - frame_system::CheckGenesis::::new(), - frame_system::CheckEra::::from(sp_runtime::generic::Era::mortal( - period, - best_block.saturated_into(), - )), - frame_system::CheckNonce::::from(nonce), - frame_system::CheckWeight::::new(), - pallet_transaction_payment::ChargeTransactionPayment::::from(0), - ); - - let raw_payload = runtime::SignedPayload::from_raw( - call.clone(), - extra.clone(), - ( - (), - runtime::VERSION.spec_version, - runtime::VERSION.transaction_version, - genesis_hash, - best_hash, - (), - (), - (), - ), - ); - let signature = raw_payload.using_encoded(|e| sender.sign(e)); - - runtime::UncheckedExtrinsic::new_signed( - call.clone(), - sp_runtime::AccountId32::from(sender.public()).into(), - runtime::Signature::Sr25519(signature.clone()), - extra.clone(), - ) -} - /// Generates inherent data for the `benchmark overhead` command. -/// -/// Note: Should only be used for benchmarking. pub fn inherent_benchmark_data() -> Result { let mut inherent_data = InherentData::new(); let d = Duration::from_millis(0); diff --git a/node/cli/src/chain_spec.rs b/node/cli/src/chain_spec.rs new file mode 100644 index 0000000..efd483f --- /dev/null +++ b/node/cli/src/chain_spec.rs @@ -0,0 +1,407 @@ +// This file is part of Substrate. + +// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Substrate chain configurations. + +use grandpa_primitives::AuthorityId as GrandpaId; +pub use node_primitives::{AccountId, Balance, Signature}; +use sc_chain_spec::ChainSpecExtension; +use sc_service::ChainType; +use sc_telemetry::TelemetryEndpoints; +use serde::{Deserialize, Serialize}; +use sp_consensus_babe::AuthorityId as BabeId; +use sp_core::{crypto::UncheckedInto, Pair, Public, sr25519}; +use sp_runtime::{ + traits::{IdentifyAccount, Verify}, +}; + +use xsocial_runtime::{BabeConfig, BalancesConfig, Block, CollatorSelectionConfig, EXISTENTIAL_DEPOSIT, GrandpaConfig, SessionConfig, SudoConfig, SystemConfig}; +pub use xsocial_runtime::GenesisConfig; +use xsocial_runtime::opaque::SessionKeys; + +type AccountPublic = ::Signer; + +const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/"; +const DEFAULT_PROTOCOL_ID: &str = "sub-xsocial-v0"; + +/// Node `ChainSpec` extensions. +/// +/// Additional parameters for some Substrate core modules, +/// customizable from the chain spec. +#[derive(Default, Clone, Serialize, Deserialize, ChainSpecExtension)] +#[serde(rename_all = "camelCase")] +pub struct Extensions { + /// Block numbers with known hashes. + pub fork_blocks: sc_client_api::ForkBlocks, + /// Known bad block hashes. + pub bad_blocks: sc_client_api::BadBlocks, + /// The light sync state extension used by the sync-state rpc. + pub light_sync_state: sc_sync_state_rpc::LightSyncStateExtension, +} + +/// Specialized `ChainSpec`. +pub type ChainSpec = sc_service::GenericChainSpec; + +/// Flaming Fir testnet generator +fn session_keys( + grandpa: GrandpaId, + babe: BabeId, +) -> SessionKeys { + SessionKeys { grandpa, babe } +} + +fn staging_testnet_config_genesis() -> GenesisConfig { + #[rustfmt::skip] + // stash, controller, session-key + // generated with secret: + // for i in 1 2 3 4 ; do for j in stash controller; do subkey inspect "$secret"/fir/$j/$i; done; done + // + // and + // + // for i in 1 2 3 4 ; do for j in session; do subkey --ed25519 inspect "$secret"//fir//$j//$i; done; done + let initial_authorities: Vec<( + AccountId, + AccountId, + GrandpaId, + BabeId, + )> = vec![ + ( + // 5Fbsd6WXDGiLTxunqeK5BATNiocfCqu9bS1yArVjCgeBLkVy + array_bytes::hex_n_into_unchecked("9c7a2ee14e565db0c69f78c7b4cd839fbf52b607d867e9e9c5a79042898a0d12"), + // 5EnCiV7wSHeNhjW3FSUwiJNkcc2SBkPLn5Nj93FmbLtBjQUq + array_bytes::hex_n_into_unchecked("781ead1e2fa9ccb74b44c19d29cb2a7a4b5be3972927ae98cd3877523976a276"), + // 5Fb9ayurnxnaXj56CjmyQLBiadfRCqUbL2VWNbbe1nZU6wiC + array_bytes::hex2array_unchecked("9becad03e6dcac03cee07edebca5475314861492cdfc96a2144a67bbe9699332") + .unchecked_into(), + // 5EZaeQ8djPcq9pheJUhgerXQZt9YaHnMJpiHMRhwQeinqUW8 + array_bytes::hex2array_unchecked("6e7e4eb42cbd2e0ab4cae8708ce5509580b8c04d11f6758dbf686d50fe9f9106") + .unchecked_into(), + ), + ( + // 5ERawXCzCWkjVq3xz1W5KGNtVx2VdefvZ62Bw1FEuZW4Vny2 + array_bytes::hex_n_into_unchecked("68655684472b743e456907b398d3a44c113f189e56d1bbfd55e889e295dfde78"), + // 5Gc4vr42hH1uDZc93Nayk5G7i687bAQdHHc9unLuyeawHipF + array_bytes::hex_n_into_unchecked("c8dc79e36b29395413399edaec3e20fcca7205fb19776ed8ddb25d6f427ec40e"), + // 5EockCXN6YkiNCDjpqqnbcqd4ad35nU4RmA1ikM4YeRN4WcE + array_bytes::hex2array_unchecked("7932cff431e748892fa48e10c63c17d30f80ca42e4de3921e641249cd7fa3c2f") + .unchecked_into(), + // 5DhLtiaQd1L1LU9jaNeeu9HJkP6eyg3BwXA7iNMzKm7qqruQ + array_bytes::hex2array_unchecked("482dbd7297a39fa145c570552249c2ca9dd47e281f0c500c971b59c9dcdcd82e") + .unchecked_into(), + ), + ( + // 5DyVtKWPidondEu8iHZgi6Ffv9yrJJ1NDNLom3X9cTDi98qp + array_bytes::hex_n_into_unchecked("547ff0ab649283a7ae01dbc2eb73932eba2fb09075e9485ff369082a2ff38d65"), + // 5FeD54vGVNpFX3PndHPXJ2MDakc462vBCD5mgtWRnWYCpZU9 + array_bytes::hex_n_into_unchecked("9e42241d7cd91d001773b0b616d523dd80e13c6c2cab860b1234ef1b9ffc1526"), + // 5E1jLYfLdUQKrFrtqoKgFrRvxM3oQPMbf6DfcsrugZZ5Bn8d + array_bytes::hex2array_unchecked("5633b70b80a6c8bb16270f82cca6d56b27ed7b76c8fd5af2986a25a4788ce440") + .unchecked_into(), + // 5DhKqkHRkndJu8vq7pi2Q5S3DfftWJHGxbEUNH43b46qNspH + array_bytes::hex2array_unchecked("482a3389a6cf42d8ed83888cfd920fec738ea30f97e44699ada7323f08c3380a") + .unchecked_into(), + ), + ( + // 5HYZnKWe5FVZQ33ZRJK1rG3WaLMztxWrrNDb1JRwaHHVWyP9 + array_bytes::hex_n_into_unchecked("f26cdb14b5aec7b2789fd5ca80f979cef3761897ae1f37ffb3e154cbcc1c2663"), + // 5EPQdAQ39WQNLCRjWsCk5jErsCitHiY5ZmjfWzzbXDoAoYbn + array_bytes::hex_n_into_unchecked("66bc1e5d275da50b72b15de072a2468a5ad414919ca9054d2695767cf650012f"), + // 5DMa31Hd5u1dwoRKgC4uvqyrdK45RHv3CpwvpUC1EzuwDit4 + array_bytes::hex2array_unchecked("3919132b851ef0fd2dae42a7e734fe547af5a6b809006100f48944d7fae8e8ef") + .unchecked_into(), + // 5C4vDQxA8LTck2xJEy4Yg1hM9qjDt4LvTQaMo4Y8ne43aU6x + array_bytes::hex2array_unchecked("00299981a2b92f878baaf5dbeba5c18d4e70f2a1fcd9c61b32ea18daf38f4378") + .unchecked_into(), + ), + ]; + + // generated with secret: subkey inspect "$secret"/fir + let root_key: AccountId = array_bytes::hex_n_into_unchecked( + // 5Ff3iXP75ruzroPWRP2FYBHWnmGGBSb63857BgnzCoXNxfPo + "9ee5e5bdc0ec239eb164f865ecc345ce4c88e76ee002e0f7e318097347471809", + ); + + let endowed_accounts: Vec = vec![root_key.clone()]; + + testnet_genesis(initial_authorities, vec![], root_key, Some(endowed_accounts)) +} + +/// Staging testnet config. +pub fn staging_testnet_config() -> ChainSpec { + let boot_nodes = vec![]; + ChainSpec::from_genesis( + "XSocial Testnet", + "xsocial_testnet", + ChainType::Live, + staging_testnet_config_genesis, + boot_nodes, + Some( + TelemetryEndpoints::new(vec![(STAGING_TELEMETRY_URL.to_string(), 0)]) + .expect("Staging telemetry url is valid; qed"), + ), + Some(DEFAULT_PROTOCOL_ID), + None, + None, + Default::default(), + ) +} + +/// Helper function to generate a crypto pair from seed +pub fn get_from_seed(seed: &str) -> ::Public { + TPublic::Pair::from_string(&format!("//{}", seed), None) + .expect("static values are valid; qed") + .public() +} + +/// Helper function to generate an account ID from seed +pub fn get_account_id_from_seed(seed: &str) -> AccountId + where + AccountPublic: From<::Public>, +{ + AccountPublic::from(get_from_seed::(seed)).into_account() +} + +/// Helper function to generate stash, controller and session key from seed +pub fn authority_keys_from_seed( + seed: &str, +) -> (AccountId, AccountId, GrandpaId, BabeId) { + ( + get_account_id_from_seed::(&format!("{}//stash", seed)), + get_account_id_from_seed::(seed), + get_from_seed::(seed), + get_from_seed::(seed), + ) +} + +/// Helper function to create GenesisConfig for testing +pub fn testnet_genesis( + initial_authorities: Vec<( + AccountId, + AccountId, + GrandpaId, + BabeId, + )>, + initial_nominators: Vec, + root_key: AccountId, + endowed_accounts: Option>, +) -> GenesisConfig { + let mut endowed_accounts: Vec = endowed_accounts.unwrap_or_else(|| { + vec![ + get_account_id_from_seed::("Alice"), + get_account_id_from_seed::("Bob"), + get_account_id_from_seed::("Charlie"), + get_account_id_from_seed::("Dave"), + get_account_id_from_seed::("Eve"), + get_account_id_from_seed::("Ferdie"), + get_account_id_from_seed::("Alice//stash"), + get_account_id_from_seed::("Bob//stash"), + get_account_id_from_seed::("Charlie//stash"), + get_account_id_from_seed::("Dave//stash"), + get_account_id_from_seed::("Eve//stash"), + get_account_id_from_seed::("Ferdie//stash"), + ] + }); + // endow all authorities and nominators. + initial_authorities + .iter() + .map(|x| &x.0) + .chain(initial_nominators.iter()) + .for_each(|x| { + if !endowed_accounts.contains(x) { + endowed_accounts.push(x.clone()) + } + }); + + let num_endowed_accounts = endowed_accounts.len(); + + const ENDOWMENT: Balance = 10_000_000 * EXISTENTIAL_DEPOSIT; + const STASH: Balance = ENDOWMENT / 1000; + + GenesisConfig { + system: SystemConfig { + code: xsocial_runtime::WASM_BINARY + .expect("WASM binary was not build, please build it!") + .to_vec(), + }, + collator_selection: CollatorSelectionConfig { + invulnerables: initial_authorities.iter().cloned().map(|(_, acc, _, _)| acc).collect(), + candidacy_bond: EXISTENTIAL_DEPOSIT * 16, + ..Default::default() + }, + balances: BalancesConfig { + balances: endowed_accounts.iter().cloned().map(|x| (x, ENDOWMENT)).collect(), + }, + session: SessionConfig { + keys: initial_authorities + .iter() + .map(|x| { + ( + x.0.clone(), + x.0.clone(), + session_keys(x.2.clone(), x.3.clone()), + ) + }) + .collect::>(), + }, + sudo: SudoConfig { key: Some(root_key.clone()) }, + babe: BabeConfig { + authorities: vec![], + epoch_config: Some(xsocial_runtime::BABE_GENESIS_EPOCH_CONFIG), + }, + grandpa: GrandpaConfig { + authorities: initial_authorities.iter().map(|x| (x.2.clone(), 1)).collect(), + }, + transaction_payment: Default::default(), + spaces: xsocial_runtime::SpacesConfig { + endowed_account: Some(root_key), + }, + } +} + +fn development_config_genesis() -> GenesisConfig { + testnet_genesis( + vec![authority_keys_from_seed("Alice")], + vec![], + get_account_id_from_seed::("Alice"), + None, + ) +} + +/// Development config (single validator Alice) +pub fn development_config() -> ChainSpec { + ChainSpec::from_genesis( + "Development", + "dev", + ChainType::Development, + development_config_genesis, + vec![], + None, + None, + None, + None, + Default::default(), + ) +} + +fn local_testnet_genesis() -> GenesisConfig { + testnet_genesis( + vec![authority_keys_from_seed("Alice"), authority_keys_from_seed("Bob")], + vec![], + get_account_id_from_seed::("Alice"), + None, + ) +} + +/// Local testnet config (multivalidator Alice + Bob) +pub fn local_testnet_config() -> ChainSpec { + ChainSpec::from_genesis( + "Local Testnet", + "local_testnet", + ChainType::Local, + local_testnet_genesis, + vec![], + None, + None, + None, + None, + Default::default(), + ) +} + +#[cfg(test)] +pub(crate) mod tests { + use sc_service_test; + use sp_runtime::BuildStorage; + + use crate::service::{new_full_base, NewFullBase}; + + use super::*; + + fn local_testnet_genesis_instant_single() -> GenesisConfig { + testnet_genesis( + vec![authority_keys_from_seed("Alice")], + vec![], + get_account_id_from_seed::("Alice"), + None, + ) + } + + /// Local testnet config (single validator - Alice) + pub fn integration_test_config_with_single_authority() -> ChainSpec { + ChainSpec::from_genesis( + "Integration Test", + "test", + ChainType::Development, + local_testnet_genesis_instant_single, + vec![], + None, + None, + None, + None, + Default::default(), + ) + } + + /// Local testnet config (multivalidator Alice + Bob) + pub fn integration_test_config_with_two_authorities() -> ChainSpec { + ChainSpec::from_genesis( + "Integration Test", + "test", + ChainType::Development, + local_testnet_genesis, + vec![], + None, + None, + None, + None, + Default::default(), + ) + } + + #[test] + #[ignore] + fn test_connectivity() { + sp_tracing::try_init_simple(); + + sc_service_test::connectivity(integration_test_config_with_two_authorities(), |config| { + let NewFullBase { task_manager, client, network, transaction_pool, .. } = + new_full_base(config, false, |_, _| ())?; + Ok(sc_service_test::TestNetComponents::new( + task_manager, + client, + network, + transaction_pool, + )) + }); + } + + #[test] + fn test_create_development_chain_spec() { + development_config().build_storage().unwrap(); + } + + #[test] + fn test_create_local_testnet_chain_spec() { + local_testnet_config().build_storage().unwrap(); + } + + #[test] + fn test_staging_test_net_chain_spec() { + staging_testnet_config().build_storage().unwrap(); + } +} diff --git a/node/cli/src/cli.rs b/node/cli/src/cli.rs new file mode 100644 index 0000000..bb7f8a4 --- /dev/null +++ b/node/cli/src/cli.rs @@ -0,0 +1,100 @@ +// This file is part of Substrate. + +// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +/// An overarching CLI command definition. +#[derive(Debug, clap::Parser)] +pub struct Cli { + /// Possible subcommand with parameters. + #[command(subcommand)] + pub subcommand: Option, + + #[allow(missing_docs)] + #[clap(flatten)] + pub run: sc_cli::RunCmd, + + /// Disable automatic hardware benchmarks. + /// + /// By default these benchmarks are automatically ran at startup and measure + /// the CPU speed, the memory bandwidth and the disk speed. + /// + /// The results are then printed out in the logs, and also sent as part of + /// telemetry, if telemetry is enabled. + #[arg(long)] + pub no_hardware_benchmarks: bool, +} + +/// Possible subcommands of the main binary. +#[derive(Debug, clap::Subcommand)] +pub enum Subcommand { + /// The custom inspect subcommmand for decoding blocks and extrinsics. + #[command( + name = "inspect", + about = "Decode given block or extrinsic using current native runtime." + )] + Inspect(node_inspect::cli::InspectCmd), + + /// Sub-commands concerned with benchmarking. + /// The pallet benchmarking moved to the `pallet` sub-command. + #[command(subcommand)] + Benchmark(frame_benchmarking_cli::BenchmarkCmd), + + /// Try some command against runtime state. + #[cfg(feature = "try-runtime")] + TryRuntime(try_runtime_cli::TryRuntimeCmd), + + /// Try some command against runtime state. Note: `try-runtime` feature must be enabled. + #[cfg(not(feature = "try-runtime"))] + TryRuntime, + + /// Key management cli utilities + #[command(subcommand)] + Key(sc_cli::KeySubcommand), + + /// Verify a signature for a message, provided on STDIN, with a given (public or secret) key. + Verify(sc_cli::VerifyCmd), + + /// Generate a seed that provides a vanity address. + Vanity(sc_cli::VanityCmd), + + /// Sign a message, with a given (secret) key. + Sign(sc_cli::SignCmd), + + /// Build a chain specification. + BuildSpec(sc_cli::BuildSpecCmd), + + /// Validate blocks. + CheckBlock(sc_cli::CheckBlockCmd), + + /// Export blocks. + ExportBlocks(sc_cli::ExportBlocksCmd), + + /// Export the state of a given block into a chain spec. + ExportState(sc_cli::ExportStateCmd), + + /// Import blocks. + ImportBlocks(sc_cli::ImportBlocksCmd), + + /// Remove the whole chain. + PurgeChain(sc_cli::PurgeChainCmd), + + /// Revert the chain to a previous state. + Revert(sc_cli::RevertCmd), + + /// Db meta columns information. + ChainInfo(sc_cli::ChainInfoCmd), +} diff --git a/node/src/command.rs b/node/cli/src/command.rs similarity index 57% rename from node/src/command.rs rename to node/cli/src/command.rs index 6fb063d..da34bbc 100644 --- a/node/src/command.rs +++ b/node/cli/src/command.rs @@ -1,18 +1,40 @@ +// This file is part of Substrate. + +// Copyright (C) 2017-2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +use super::benchmarking::{inherent_benchmark_data, RemarkBuilder, TransferKeepAliveBuilder}; use crate::{ - benchmarking::{inherent_benchmark_data, RemarkBuilder, TransferKeepAliveBuilder}, - chain_spec, - cli::{Cli, Subcommand}, - service, + chain_spec, service, + service::{new_partial, FullClient}, + Cli, Subcommand, }; -use frame_benchmarking_cli::{BenchmarkCmd, ExtrinsicFactory, SUBSTRATE_REFERENCE_HARDWARE}; -use xsocial_runtime::{Block, EXISTENTIAL_DEPOSIT}; -use sc_cli::{ChainSpec, RuntimeVersion, SubstrateCli}; +use frame_benchmarking_cli::*; +use xsocial_runtime::{ExistentialDeposit, RuntimeApi}; +use node_executor::ExecutorDispatch; +use node_primitives::Block; +use sc_cli::{ChainSpec, Result, RuntimeVersion, SubstrateCli}; use sc_service::PartialComponents; use sp_keyring::Sr25519Keyring; +use std::sync::Arc; + impl SubstrateCli for Cli { fn impl_name() -> String { - "XSocial Node".into() + "Substrate Node".into() } fn impl_version() -> String { @@ -28,22 +50,27 @@ impl SubstrateCli for Cli { } fn support_url() -> String { - "https://github.com/dappforce/xsocial-testnet/issues/new".into() + "https://github.com/paritytech/substrate/issues/new".into() } fn copyright_start_year() -> i32 { - 2023 + 2017 } - fn load_spec(&self, id: &str) -> Result, String> { - Ok(match id { - "dev" => Box::new(chain_spec::development_config()?), - "local" => Box::new(chain_spec::local_testnet_config()?), - "staging" => Box::new(chain_spec::staging_testnet_config()?), - "" | "xsocial" => Box::new(chain_spec::xsocial_testnet_config()?), + fn load_spec(&self, id: &str) -> std::result::Result, String> { + let spec = match id { + "" => + return Err( + "Please specify which chain you want to run, e.g. --dev or --chain=local" + .into(), + ), + "dev" => Box::new(chain_spec::development_config()), + "local" => Box::new(chain_spec::local_testnet_config()), + "staging" => Box::new(chain_spec::staging_testnet_config()), path => Box::new(chain_spec::ChainSpec::from_json_file(std::path::PathBuf::from(path))?), - }) + }; + Ok(spec) } fn native_runtime_version(_: &Box) -> &'static RuntimeVersion { @@ -51,61 +78,22 @@ impl SubstrateCli for Cli { } } -/// Parse and run command line arguments -pub fn run() -> sc_cli::Result<()> { +/// Parse command line arguments into service configuration. +pub fn run() -> Result<()> { let cli = Cli::from_args(); match &cli.subcommand { - Some(Subcommand::Key(cmd)) => cmd.run(&cli), - Some(Subcommand::BuildSpec(cmd)) => { - let runner = cli.create_runner(cmd)?; - runner.sync_run(|config| cmd.run(config.chain_spec, config.network)) - }, - Some(Subcommand::CheckBlock(cmd)) => { - let runner = cli.create_runner(cmd)?; - runner.async_run(|config| { - let PartialComponents { client, task_manager, import_queue, .. } = - service::new_partial(&config)?; - Ok((cmd.run(client, import_queue), task_manager)) - }) - }, - Some(Subcommand::ExportBlocks(cmd)) => { - let runner = cli.create_runner(cmd)?; - runner.async_run(|config| { - let PartialComponents { client, task_manager, .. } = service::new_partial(&config)?; - Ok((cmd.run(client, config.database), task_manager)) - }) - }, - Some(Subcommand::ExportState(cmd)) => { - let runner = cli.create_runner(cmd)?; - runner.async_run(|config| { - let PartialComponents { client, task_manager, .. } = service::new_partial(&config)?; - Ok((cmd.run(client, config.chain_spec), task_manager)) - }) - }, - Some(Subcommand::ImportBlocks(cmd)) => { - let runner = cli.create_runner(cmd)?; - runner.async_run(|config| { - let PartialComponents { client, task_manager, import_queue, .. } = - service::new_partial(&config)?; - Ok((cmd.run(client, import_queue), task_manager)) + None => { + let runner = cli.create_runner(&cli.run)?; + runner.run_node_until_exit(|config| async move { + service::new_full(config, cli.no_hardware_benchmarks) + .map_err(sc_cli::Error::Service) }) }, - Some(Subcommand::PurgeChain(cmd)) => { + Some(Subcommand::Inspect(cmd)) => { let runner = cli.create_runner(cmd)?; - runner.sync_run(|config| cmd.run(config.database)) - }, - Some(Subcommand::Revert(cmd)) => { - let runner = cli.create_runner(cmd)?; - runner.async_run(|config| { - let PartialComponents { client, task_manager, backend, .. } = - service::new_partial(&config)?; - let aux_revert = Box::new(|client, _, blocks| { - sc_finality_grandpa::revert(client, blocks)?; - Ok(()) - }); - Ok((cmd.run(client, backend, Some(aux_revert)), task_manager)) - }) + + runner.sync_run(|config| cmd.run::(config)) }, Some(Subcommand::Benchmark(cmd)) => { let runner = cli.create_runner(cmd)?; @@ -123,11 +111,12 @@ pub fn run() -> sc_cli::Result<()> { ) } - cmd.run::(config) + cmd.run::(config) }, BenchmarkCmd::Block(cmd) => { - let PartialComponents { client, .. } = service::new_partial(&config)?; - cmd.run(client) + // ensure that we keep the task manager alive + let partial = new_partial(&config)?; + cmd.run(partial.client) }, #[cfg(not(feature = "runtime-benchmarks"))] BenchmarkCmd::Storage(_) => Err( @@ -136,47 +125,107 @@ pub fn run() -> sc_cli::Result<()> { ), #[cfg(feature = "runtime-benchmarks")] BenchmarkCmd::Storage(cmd) => { - let PartialComponents { client, backend, .. } = - service::new_partial(&config)?; - let db = backend.expose_db(); - let storage = backend.expose_storage(); + // ensure that we keep the task manager alive + let partial = new_partial(&config)?; + let db = partial.backend.expose_db(); + let storage = partial.backend.expose_storage(); - cmd.run(config, client, db, storage) + cmd.run(config, partial.client, db, storage) }, BenchmarkCmd::Overhead(cmd) => { - let PartialComponents { client, .. } = service::new_partial(&config)?; - let ext_builder = RemarkBuilder::new(client.clone()); + // ensure that we keep the task manager alive + let partial = new_partial(&config)?; + let ext_builder = RemarkBuilder::new(partial.client.clone()); cmd.run( config, - client, + partial.client, inherent_benchmark_data()?, Vec::new(), &ext_builder, ) }, BenchmarkCmd::Extrinsic(cmd) => { - let PartialComponents { client, .. } = service::new_partial(&config)?; + // ensure that we keep the task manager alive + let partial = service::new_partial(&config)?; // Register the *Remark* and *TKA* builders. let ext_factory = ExtrinsicFactory(vec![ - Box::new(RemarkBuilder::new(client.clone())), + Box::new(RemarkBuilder::new(partial.client.clone())), Box::new(TransferKeepAliveBuilder::new( - client.clone(), + partial.client.clone(), Sr25519Keyring::Alice.to_account_id(), - EXISTENTIAL_DEPOSIT, + ExistentialDeposit::get(), )), ]); - cmd.run(client, inherent_benchmark_data()?, Vec::new(), &ext_factory) + cmd.run( + partial.client, + inherent_benchmark_data()?, + Vec::new(), + &ext_factory, + ) }, BenchmarkCmd::Machine(cmd) => cmd.run(&config, SUBSTRATE_REFERENCE_HARDWARE.clone()), } }) }, + Some(Subcommand::Key(cmd)) => cmd.run(&cli), + Some(Subcommand::Sign(cmd)) => cmd.run(), + Some(Subcommand::Verify(cmd)) => cmd.run(), + Some(Subcommand::Vanity(cmd)) => cmd.run(), + Some(Subcommand::BuildSpec(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.sync_run(|config| cmd.run(config.chain_spec, config.network)) + }, + Some(Subcommand::CheckBlock(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.async_run(|config| { + let PartialComponents { client, task_manager, import_queue, .. } = + new_partial(&config)?; + Ok((cmd.run(client, import_queue), task_manager)) + }) + }, + Some(Subcommand::ExportBlocks(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.async_run(|config| { + let PartialComponents { client, task_manager, .. } = new_partial(&config)?; + Ok((cmd.run(client, config.database), task_manager)) + }) + }, + Some(Subcommand::ExportState(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.async_run(|config| { + let PartialComponents { client, task_manager, .. } = new_partial(&config)?; + Ok((cmd.run(client, config.chain_spec), task_manager)) + }) + }, + Some(Subcommand::ImportBlocks(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.async_run(|config| { + let PartialComponents { client, task_manager, import_queue, .. } = + new_partial(&config)?; + Ok((cmd.run(client, import_queue), task_manager)) + }) + }, + Some(Subcommand::PurgeChain(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.sync_run(|config| cmd.run(config.database)) + }, + Some(Subcommand::Revert(cmd)) => { + let runner = cli.create_runner(cmd)?; + runner.async_run(|config| { + let PartialComponents { client, task_manager, backend, .. } = new_partial(&config)?; + let aux_revert = Box::new(|client: Arc, backend, blocks| { + sc_consensus_babe::revert(client.clone(), backend, blocks)?; + grandpa::revert(client, blocks)?; + Ok(()) + }); + Ok((cmd.run(client, backend, Some(aux_revert)), task_manager)) + }) + }, #[cfg(feature = "try-runtime")] Some(Subcommand::TryRuntime(cmd)) => { - use crate::service::ExecutorDispatch; use sc_executor::{sp_wasm_interface::ExtendedHostFunctions, NativeExecutionDispatch}; let runner = cli.create_runner(cmd)?; runner.async_run(|config| { @@ -186,6 +235,7 @@ pub fn run() -> sc_cli::Result<()> { let task_manager = sc_service::TaskManager::new(config.tokio_handle.clone(), registry) .map_err(|e| sc_cli::Error::Service(sc_service::Error::Prometheus(e)))?; + Ok(( cmd.run:: sc_cli::Result<()> { let runner = cli.create_runner(cmd)?; runner.sync_run(|config| cmd.run::(&config)) }, - None => { - let runner = cli.create_runner(&cli.run)?; - runner.run_node_until_exit(|config| async move { - service::new_full(config).map_err(sc_cli::Error::Service) - }) - }, } } diff --git a/node/cli/src/lib.rs b/node/cli/src/lib.rs new file mode 100644 index 0000000..13c0742 --- /dev/null +++ b/node/cli/src/lib.rs @@ -0,0 +1,47 @@ +// This file is part of Substrate. + +// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +//! Substrate CLI library. +//! +//! This package has two Cargo features: +//! +//! - `cli` (default): exposes functions that parse command-line options, then start and run the +//! node as a CLI application. +//! +//! - `browser`: exposes the content of the `browser` module, which consists of exported symbols +//! that are meant to be passed through the `wasm-bindgen` utility and called from JavaScript. +//! Despite its name the produced WASM can theoretically also be used from NodeJS, although this +//! hasn't been tested. + +#![warn(missing_docs)] + +pub mod chain_spec; + +#[macro_use] +pub mod service; +#[cfg(feature = "cli")] +mod benchmarking; +#[cfg(feature = "cli")] +mod cli; +#[cfg(feature = "cli")] +mod command; + +#[cfg(feature = "cli")] +pub use cli::*; +#[cfg(feature = "cli")] +pub use command::*; diff --git a/node/cli/src/service.rs b/node/cli/src/service.rs new file mode 100644 index 0000000..56bd02c --- /dev/null +++ b/node/cli/src/service.rs @@ -0,0 +1,817 @@ +// This file is part of Substrate. + +// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0 + +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . + +#![warn(unused_extern_crates)] + +//! Service implementation. Specialized wrapper over substrate service. + +use codec::Encode; +use frame_system_rpc_runtime_api::AccountNonceApi; +use futures::prelude::*; +use xsocial_runtime::RuntimeApi; +use node_executor::ExecutorDispatch; +use node_primitives::Block; +use sc_client_api::BlockBackend; +use sc_consensus_babe::{self, SlotProportion}; +use sc_executor::NativeElseWasmExecutor; +use sc_network::NetworkService; +use sc_network_common::{protocol::event::Event, service::NetworkEventStream}; +use sc_service::{config::Configuration, error::Error as ServiceError, RpcHandlers, TaskManager}; +use sc_telemetry::{Telemetry, TelemetryWorker}; +use sp_api::ProvideRuntimeApi; +use sp_core::crypto::Pair; +use sp_runtime::{generic, traits::Block as BlockT, SaturatedConversion}; +use std::sync::Arc; + +/// The full client type definition. +pub type FullClient = + sc_service::TFullClient>; +type FullBackend = sc_service::TFullBackend; +type FullSelectChain = sc_consensus::LongestChain; +type FullGrandpaBlockImport = + grandpa::GrandpaBlockImport; + +/// The transaction pool type defintion. +pub type TransactionPool = sc_transaction_pool::FullPool; + +/// Fetch the nonce of the given `account` from the chain state. +/// +/// Note: Should only be used for tests. +pub fn fetch_nonce(client: &FullClient, account: sp_core::sr25519::Pair) -> u32 { + let best_hash = client.chain_info().best_hash; + client + .runtime_api() + .account_nonce(&generic::BlockId::Hash(best_hash), account.public().into()) + .expect("Fetching account nonce works; qed") +} + +/// Create a transaction using the given `call`. +/// +/// The transaction will be signed by `sender`. If `nonce` is `None` it will be fetched from the +/// state of the best block. +/// +/// Note: Should only be used for tests. +pub fn create_extrinsic( + client: &FullClient, + sender: sp_core::sr25519::Pair, + function: impl Into, + nonce: Option, +) -> xsocial_runtime::UncheckedExtrinsic { + let function = function.into(); + let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"); + let best_hash = client.chain_info().best_hash; + let best_block = client.chain_info().best_number; + let nonce = nonce.unwrap_or_else(|| fetch_nonce(client, sender.clone())); + + let period = xsocial_runtime::BlockHashCount::get() + .checked_next_power_of_two() + .map(|c| c / 2) + .unwrap_or(2) as u64; + let tip = 0; + let extra: xsocial_runtime::SignedExtra = ( + frame_system::CheckNonZeroSender::::new(), + frame_system::CheckSpecVersion::::new(), + frame_system::CheckTxVersion::::new(), + frame_system::CheckGenesis::::new(), + frame_system::CheckEra::::from(generic::Era::mortal( + period, + best_block.saturated_into(), + )), + frame_system::CheckNonce::::from(nonce), + frame_system::CheckWeight::::new(), + pallet_transaction_payment::ChargeTransactionPayment::::from(tip), + // pallet_asset_tx_payment::ChargeAssetTxPayment::::from( + // tip, None, + // ), + ); + + let raw_payload = xsocial_runtime::SignedPayload::from_raw( + function.clone(), + extra.clone(), + ( + (), + xsocial_runtime::VERSION.spec_version, + xsocial_runtime::VERSION.transaction_version, + genesis_hash, + best_hash, + (), + (), + (), + ), + ); + let signature = raw_payload.using_encoded(|e| sender.sign(e)); + + xsocial_runtime::UncheckedExtrinsic::new_signed( + function, + sp_runtime::AccountId32::from(sender.public()).into(), + xsocial_runtime::Signature::Sr25519(signature), + extra, + ) +} + +/// Creates a new partial node. +pub fn new_partial( + config: &Configuration, +) -> Result< + sc_service::PartialComponents< + FullClient, + FullBackend, + FullSelectChain, + sc_consensus::DefaultImportQueue, + sc_transaction_pool::FullPool, + ( + impl Fn( + node_rpc::DenyUnsafe, + sc_rpc::SubscriptionTaskExecutor, + ) -> Result, sc_service::Error>, + ( + sc_consensus_babe::BabeBlockImport, + grandpa::LinkHalf, + sc_consensus_babe::BabeLink, + ), + grandpa::SharedVoterState, + Option, + ), + >, + ServiceError, +> { + let telemetry = config + .telemetry_endpoints + .clone() + .filter(|x| !x.is_empty()) + .map(|endpoints| -> Result<_, sc_telemetry::Error> { + let worker = TelemetryWorker::new(16)?; + let telemetry = worker.handle().new_telemetry(endpoints); + Ok((worker, telemetry)) + }) + .transpose()?; + + let executor = NativeElseWasmExecutor::::new( + config.wasm_method, + config.default_heap_pages, + config.max_runtime_instances, + config.runtime_cache_size, + ); + + let (client, backend, keystore_container, task_manager) = + sc_service::new_full_parts::( + config, + telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()), + executor, + )?; + let client = Arc::new(client); + + let telemetry = telemetry.map(|(worker, telemetry)| { + task_manager.spawn_handle().spawn("telemetry", None, worker.run()); + telemetry + }); + + let select_chain = sc_consensus::LongestChain::new(backend.clone()); + + let transaction_pool = sc_transaction_pool::BasicPool::new_full( + config.transaction_pool.clone(), + config.role.is_authority().into(), + config.prometheus_registry(), + task_manager.spawn_essential_handle(), + client.clone(), + ); + + let (grandpa_block_import, grandpa_link) = grandpa::block_import( + client.clone(), + &(client.clone() as Arc<_>), + select_chain.clone(), + telemetry.as_ref().map(|x| x.handle()), + )?; + let justification_import = grandpa_block_import.clone(); + + let (block_import, babe_link) = sc_consensus_babe::block_import( + sc_consensus_babe::configuration(&*client)?, + grandpa_block_import, + client.clone(), + )?; + + let slot_duration = babe_link.config().slot_duration(); + let import_queue = sc_consensus_babe::import_queue( + babe_link.clone(), + block_import.clone(), + Some(Box::new(justification_import)), + client.clone(), + select_chain.clone(), + move |_, ()| async move { + let timestamp = sp_timestamp::InherentDataProvider::from_system_time(); + + let slot = + sp_consensus_babe::inherents::InherentDataProvider::from_timestamp_and_slot_duration( + *timestamp, + slot_duration, + ); + + let uncles = + sp_authorship::InherentDataProvider::<::Header>::check_inherents(); + + Ok((slot, timestamp, uncles)) + }, + &task_manager.spawn_essential_handle(), + config.prometheus_registry(), + telemetry.as_ref().map(|x| x.handle()), + )?; + + let import_setup = (block_import, grandpa_link, babe_link); + + let (rpc_extensions_builder, rpc_setup) = { + let (_, grandpa_link, babe_link) = &import_setup; + + let justification_stream = grandpa_link.justification_stream(); + let shared_authority_set = grandpa_link.shared_authority_set().clone(); + let shared_voter_state = grandpa::SharedVoterState::empty(); + let shared_voter_state2 = shared_voter_state.clone(); + + let finality_proof_provider = grandpa::FinalityProofProvider::new_for_service( + backend.clone(), + Some(shared_authority_set.clone()), + ); + + let babe_config = babe_link.config().clone(); + let shared_epoch_changes = babe_link.epoch_changes().clone(); + + let client = client.clone(); + let pool = transaction_pool.clone(); + let select_chain = select_chain.clone(); + let keystore = keystore_container.sync_keystore(); + let chain_spec = config.chain_spec.cloned_box(); + + let rpc_backend = backend.clone(); + let rpc_extensions_builder = move |deny_unsafe, subscription_executor| { + let deps = node_rpc::FullDeps { + client: client.clone(), + pool: pool.clone(), + select_chain: select_chain.clone(), + chain_spec: chain_spec.cloned_box(), + deny_unsafe, + babe: node_rpc::BabeDeps { + babe_config: babe_config.clone(), + shared_epoch_changes: shared_epoch_changes.clone(), + keystore: keystore.clone(), + }, + grandpa: node_rpc::GrandpaDeps { + shared_voter_state: shared_voter_state.clone(), + shared_authority_set: shared_authority_set.clone(), + justification_stream: justification_stream.clone(), + subscription_executor, + finality_provider: finality_proof_provider.clone(), + }, + }; + + node_rpc::create_full(deps, rpc_backend.clone()).map_err(Into::into) + }; + + (rpc_extensions_builder, shared_voter_state2) + }; + + Ok(sc_service::PartialComponents { + client, + backend, + task_manager, + keystore_container, + select_chain, + import_queue, + transaction_pool, + other: (rpc_extensions_builder, import_setup, rpc_setup, telemetry), + }) +} + +/// Result of [`new_full_base`]. +pub struct NewFullBase { + /// The task manager of the node. + pub task_manager: TaskManager, + /// The client instance of the node. + pub client: Arc, + /// The networking service of the node. + pub network: Arc::Hash>>, + /// The transaction pool of the node. + pub transaction_pool: Arc, + /// The rpc handlers of the node. + pub rpc_handlers: RpcHandlers, +} + +/// Creates a full service from the configuration. +pub fn new_full_base( + mut config: Configuration, + disable_hardware_benchmarks: bool, + with_startup_data: impl FnOnce( + &sc_consensus_babe::BabeBlockImport, + &sc_consensus_babe::BabeLink, + ), +) -> Result { + let hwbench = if !disable_hardware_benchmarks { + config.database.path().map(|database_path| { + let _ = std::fs::create_dir_all(&database_path); + sc_sysinfo::gather_hwbench(Some(database_path)) + }) + } else { + None + }; + + let sc_service::PartialComponents { + client, + backend, + mut task_manager, + import_queue, + keystore_container, + select_chain, + transaction_pool, + other: (rpc_builder, import_setup, rpc_setup, mut telemetry), + } = new_partial(&config)?; + + let shared_voter_state = rpc_setup; + let auth_disc_publish_non_global_ips = config.network.allow_non_globals_in_dht; + let grandpa_protocol_name = grandpa::protocol_standard_name( + &client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"), + &config.chain_spec, + ); + + config + .network + .extra_sets + .push(grandpa::grandpa_peers_set_config(grandpa_protocol_name.clone())); + let warp_sync = Arc::new(grandpa::warp_proof::NetworkProvider::new( + backend.clone(), + import_setup.1.shared_authority_set().clone(), + Vec::default(), + )); + + let (network, system_rpc_tx, tx_handler_controller, network_starter) = + sc_service::build_network(sc_service::BuildNetworkParams { + config: &config, + client: client.clone(), + transaction_pool: transaction_pool.clone(), + spawn_handle: task_manager.spawn_handle(), + import_queue, + block_announce_validator_builder: None, + warp_sync: Some(warp_sync), + })?; + + if config.offchain_worker.enabled { + sc_service::build_offchain_workers( + &config, + task_manager.spawn_handle(), + client.clone(), + network.clone(), + ); + } + + let role = config.role.clone(); + let force_authoring = config.force_authoring; + let backoff_authoring_blocks = + Some(sc_consensus_slots::BackoffAuthoringOnFinalizedHeadLagging::default()); + let name = config.network.node_name.clone(); + let enable_grandpa = !config.disable_grandpa; + let prometheus_registry = config.prometheus_registry().cloned(); + + let rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams { + config, + backend, + client: client.clone(), + keystore: keystore_container.sync_keystore(), + network: network.clone(), + rpc_builder: Box::new(rpc_builder), + transaction_pool: transaction_pool.clone(), + task_manager: &mut task_manager, + system_rpc_tx, + tx_handler_controller, + telemetry: telemetry.as_mut(), + })?; + + if let Some(hwbench) = hwbench { + sc_sysinfo::print_hwbench(&hwbench); + + if let Some(ref mut telemetry) = telemetry { + let telemetry_handle = telemetry.handle(); + task_manager.spawn_handle().spawn( + "telemetry_hwbench", + None, + sc_sysinfo::initialize_hwbench_telemetry(telemetry_handle, hwbench), + ); + } + } + + let (block_import, grandpa_link, babe_link) = import_setup; + + (with_startup_data)(&block_import, &babe_link); + + if let sc_service::config::Role::Authority { .. } = &role { + let proposer = sc_basic_authorship::ProposerFactory::new( + task_manager.spawn_handle(), + client.clone(), + transaction_pool.clone(), + prometheus_registry.as_ref(), + telemetry.as_ref().map(|x| x.handle()), + ); + + let client_clone = client.clone(); + let slot_duration = babe_link.config().slot_duration(); + let babe_config = sc_consensus_babe::BabeParams { + keystore: keystore_container.sync_keystore(), + client: client.clone(), + select_chain, + env: proposer, + block_import, + sync_oracle: network.clone(), + justification_sync_link: network.clone(), + create_inherent_data_providers: move |parent, ()| { + let client_clone = client_clone.clone(); + async move { + let uncles = sc_consensus_uncles::create_uncles_inherent_data_provider( + &*client_clone, + parent, + )?; + + let timestamp = sp_timestamp::InherentDataProvider::from_system_time(); + + let slot = + sp_consensus_babe::inherents::InherentDataProvider::from_timestamp_and_slot_duration( + *timestamp, + slot_duration, + ); + + let storage_proof = + sp_transaction_storage_proof::registration::new_data_provider( + &*client_clone, + &parent, + )?; + + Ok((slot, timestamp, uncles, storage_proof)) + } + }, + force_authoring, + backoff_authoring_blocks, + babe_link, + block_proposal_slot_portion: SlotProportion::new(0.5), + max_block_proposal_slot_portion: None, + telemetry: telemetry.as_ref().map(|x| x.handle()), + }; + + let babe = sc_consensus_babe::start_babe(babe_config)?; + task_manager.spawn_essential_handle().spawn_blocking( + "babe-proposer", + Some("block-authoring"), + babe, + ); + } + + // // Spawn authority discovery module. + // if role.is_authority() { + // let authority_discovery_role = + // sc_authority_discovery::Role::PublishAndDiscover(keystore_container.keystore()); + // let dht_event_stream = + // network.event_stream("authority-discovery").filter_map(|e| async move { + // match e { + // Event::Dht(e) => Some(e), + // _ => None, + // } + // }); + // let (authority_discovery_worker, _service) = + // sc_authority_discovery::new_worker_and_service_with_config( + // sc_authority_discovery::WorkerConfig { + // publish_non_global_ips: auth_disc_publish_non_global_ips, + // ..Default::default() + // }, + // client.clone(), + // network.clone(), + // Box::pin(dht_event_stream), + // authority_discovery_role, + // prometheus_registry.clone(), + // ); + // + // task_manager.spawn_handle().spawn( + // "authority-discovery-worker", + // Some("networking"), + // authority_discovery_worker.run(), + // ); + // } + + // if the node isn't actively participating in consensus then it doesn't + // need a keystore, regardless of which protocol we use below. + let keystore = + if role.is_authority() { Some(keystore_container.sync_keystore()) } else { None }; + + let config = grandpa::Config { + // FIXME #1578 make this available through chainspec + gossip_duration: std::time::Duration::from_millis(333), + justification_period: 512, + name: Some(name), + observer_enabled: false, + keystore, + local_role: role, + telemetry: telemetry.as_ref().map(|x| x.handle()), + protocol_name: grandpa_protocol_name, + }; + + if enable_grandpa { + // start the full GRANDPA voter + // NOTE: non-authorities could run the GRANDPA observer protocol, but at + // this point the full voter should provide better guarantees of block + // and vote data availability than the observer. The observer has not + // been tested extensively yet and having most nodes in a network run it + // could lead to finality stalls. + let grandpa_config = grandpa::GrandpaParams { + config, + link: grandpa_link, + network: network.clone(), + telemetry: telemetry.as_ref().map(|x| x.handle()), + voting_rule: grandpa::VotingRulesBuilder::default().build(), + prometheus_registry, + shared_voter_state, + }; + + // the GRANDPA voter task is considered infallible, i.e. + // if it fails we take down the service with it. + task_manager.spawn_essential_handle().spawn_blocking( + "grandpa-voter", + None, + grandpa::run_grandpa_voter(grandpa_config)?, + ); + } + + network_starter.start_network(); + Ok(NewFullBase { task_manager, client, network, transaction_pool, rpc_handlers }) +} + +/// Builds a new service for a full client. +pub fn new_full( + config: Configuration, + disable_hardware_benchmarks: bool, +) -> Result { + new_full_base(config, disable_hardware_benchmarks, |_, _| ()) + .map(|NewFullBase { task_manager, .. }| task_manager) +} + +#[cfg(test)] +mod tests { + use crate::service::{new_full_base, NewFullBase}; + use codec::Encode; + use xsocial_runtime::{ + constants::{currency::CENTS, time::SLOT_DURATION}, + Address, BalancesCall, RuntimeCall, UncheckedExtrinsic, + }; + use node_primitives::{Block, DigestItem, Signature}; + use sc_client_api::BlockBackend; + use sc_consensus::{BlockImport, BlockImportParams, ForkChoiceStrategy}; + use sc_consensus_babe::{BabeIntermediate, CompatibleDigestItem, INTERMEDIATE_KEY}; + use sc_consensus_epochs::descendent_query; + use sc_keystore::LocalKeystore; + use sc_service_test::TestNetNode; + use sc_transaction_pool_api::{ChainEvent, MaintainedTransactionPool}; + use sp_consensus::{BlockOrigin, Environment, Proposer}; + use sp_core::{crypto::Pair as CryptoPair, Public}; + use sp_inherents::InherentDataProvider; + use sp_keyring::AccountKeyring; + use sp_keystore::{SyncCryptoStore, SyncCryptoStorePtr}; + use sp_runtime::{ + generic::{BlockId, Digest, Era, SignedPayload}, + key_types::BABE, + traits::{Block as BlockT, Header as HeaderT, IdentifyAccount, Verify}, + RuntimeAppPublic, + }; + use sp_timestamp; + use std::sync::Arc; + + type AccountPublic = ::Signer; + + #[test] + // It is "ignored", but the node-cli ignored tests are running on the CI. + // This can be run locally with `cargo test --release -p node-cli test_sync -- --ignored`. + #[ignore] + fn test_sync() { + sp_tracing::try_init_simple(); + + let keystore_path = tempfile::tempdir().expect("Creates keystore path"); + let keystore: SyncCryptoStorePtr = + Arc::new(LocalKeystore::open(keystore_path.path(), None).expect("Creates keystore")); + let alice: sp_consensus_babe::AuthorityId = + SyncCryptoStore::sr25519_generate_new(&*keystore, BABE, Some("//Alice")) + .expect("Creates authority pair") + .into(); + + let chain_spec = crate::chain_spec::tests::integration_test_config_with_single_authority(); + + // For the block factory + let mut slot = 1u64; + + // For the extrinsics factory + let bob = Arc::new(AccountKeyring::Bob.pair()); + let charlie = Arc::new(AccountKeyring::Charlie.pair()); + let mut index = 0; + + sc_service_test::sync( + chain_spec, + |config| { + let mut setup_handles = None; + let NewFullBase { task_manager, client, network, transaction_pool, .. } = + new_full_base( + config, + false, + |block_import: &sc_consensus_babe::BabeBlockImport, + babe_link: &sc_consensus_babe::BabeLink| { + setup_handles = Some((block_import.clone(), babe_link.clone())); + }, + )?; + + let node = sc_service_test::TestNetComponents::new( + task_manager, + client, + network, + transaction_pool, + ); + Ok((node, setup_handles.unwrap())) + }, + |service, &mut (ref mut block_import, ref babe_link)| { + let parent_hash = service.client().chain_info().best_hash; + let parent_header = service.client().header(parent_hash).unwrap().unwrap(); + let parent_number = *parent_header.number(); + + futures::executor::block_on(service.transaction_pool().maintain( + ChainEvent::NewBestBlock { hash: parent_header.hash(), tree_route: None }, + )); + + let mut proposer_factory = sc_basic_authorship::ProposerFactory::new( + service.spawn_handle(), + service.client(), + service.transaction_pool(), + None, + None, + ); + + let mut digest = Digest::default(); + + // even though there's only one authority some slots might be empty, + // so we must keep trying the next slots until we can claim one. + let (babe_pre_digest, epoch_descriptor) = loop { + let epoch_descriptor = babe_link + .epoch_changes() + .shared_data() + .epoch_descriptor_for_child_of( + descendent_query(&*service.client()), + &parent_hash, + parent_number, + slot.into(), + ) + .unwrap() + .unwrap(); + + let epoch = babe_link + .epoch_changes() + .shared_data() + .epoch_data(&epoch_descriptor, |slot| { + sc_consensus_babe::Epoch::genesis(babe_link.config(), slot) + }) + .unwrap(); + + if let Some(babe_pre_digest) = + sc_consensus_babe::authorship::claim_slot(slot.into(), &epoch, &keystore) + .map(|(digest, _)| digest) + { + break (babe_pre_digest, epoch_descriptor) + } + + slot += 1; + }; + + let inherent_data = futures::executor::block_on( + ( + sp_timestamp::InherentDataProvider::new( + std::time::Duration::from_millis(SLOT_DURATION * slot).into(), + ), + sp_consensus_babe::inherents::InherentDataProvider::new(slot.into()), + ) + .create_inherent_data(), + ) + .expect("Creates inherent data"); + + digest.push(::babe_pre_digest(babe_pre_digest)); + + let new_block = futures::executor::block_on(async move { + let proposer = proposer_factory.init(&parent_header).await; + proposer + .unwrap() + .propose(inherent_data, digest, std::time::Duration::from_secs(1), None) + .await + }) + .expect("Error making test block") + .block; + + let (new_header, new_body) = new_block.deconstruct(); + let pre_hash = new_header.hash(); + // sign the pre-sealed hash of the block and then + // add it to a digest item. + let to_sign = pre_hash.encode(); + let signature = SyncCryptoStore::sign_with( + &*keystore, + sp_consensus_babe::AuthorityId::ID, + &alice.to_public_crypto_pair(), + &to_sign, + ) + .unwrap() + .unwrap() + .try_into() + .unwrap(); + let item = ::babe_seal(signature); + slot += 1; + + let mut params = BlockImportParams::new(BlockOrigin::File, new_header); + params.post_digests.push(item); + params.body = Some(new_body); + params.insert_intermediate( + INTERMEDIATE_KEY, + BabeIntermediate:: { epoch_descriptor }, + ); + params.fork_choice = Some(ForkChoiceStrategy::LongestChain); + + futures::executor::block_on(block_import.import_block(params, Default::default())) + .expect("error importing test block"); + }, + |service, _| { + let amount = 5 * CENTS; + let to: Address = AccountPublic::from(bob.public()).into_account().into(); + let from: Address = AccountPublic::from(charlie.public()).into_account().into(); + let genesis_hash = service.client().block_hash(0).unwrap().unwrap(); + let best_block_id = BlockId::number(service.client().chain_info().best_number); + let (spec_version, transaction_version) = { + let version = service.client().runtime_version_at(&best_block_id).unwrap(); + (version.spec_version, version.transaction_version) + }; + let signer = charlie.clone(); + + let function = RuntimeCall::Balances(BalancesCall::transfer { + dest: to.into(), + value: amount, + }); + + let check_non_zero_sender = frame_system::CheckNonZeroSender::new(); + let check_spec_version = frame_system::CheckSpecVersion::new(); + let check_tx_version = frame_system::CheckTxVersion::new(); + let check_genesis = frame_system::CheckGenesis::new(); + let check_era = frame_system::CheckEra::from(Era::Immortal); + let check_nonce = frame_system::CheckNonce::from(index); + let check_weight = frame_system::CheckWeight::new(); + let tx_payment = pallet_asset_tx_payment::ChargeAssetTxPayment::from(0, None); + let extra = ( + check_non_zero_sender, + check_spec_version, + check_tx_version, + check_genesis, + check_era, + check_nonce, + check_weight, + tx_payment, + ); + let raw_payload = SignedPayload::from_raw( + function, + extra, + ((), spec_version, transaction_version, genesis_hash, genesis_hash, (), (), ()), + ); + let signature = raw_payload.using_encoded(|payload| signer.sign(payload)); + let (function, extra, _) = raw_payload.deconstruct(); + index += 1; + UncheckedExtrinsic::new_signed(function, from.into(), signature.into(), extra) + .into() + }, + ); + } + + #[test] + #[ignore] + fn test_consensus() { + sp_tracing::try_init_simple(); + + sc_service_test::consensus( + crate::chain_spec::tests::integration_test_config_with_two_authorities(), + |config| { + let NewFullBase { task_manager, client, network, transaction_pool, .. } = + new_full_base(config, false, |_, _| ())?; + Ok(sc_service_test::TestNetComponents::new( + task_manager, + client, + network, + transaction_pool, + )) + }, + vec!["//Alice".into(), "//Bob".into()], + ) + } +} diff --git a/node/executor/Cargo.toml b/node/executor/Cargo.toml new file mode 100644 index 0000000..a61e372 --- /dev/null +++ b/node/executor/Cargo.toml @@ -0,0 +1,50 @@ +[package] +name = "node-executor" +version = "3.0.0-dev" +authors = ["Parity Technologies "] +description = "Substrate node implementation in Rust." +edition = "2021" +license = "Apache-2.0" +homepage = "https://substrate.io" +repository = "https://github.com/paritytech/substrate/" +publish = false + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +codec = { package = "parity-scale-codec", version = "3.0.0" } +scale-info = { version = "2.1.1", features = ["derive"] } +frame-benchmarking = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +node-primitives = { version = "2.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +xsocial-runtime = { path = "../../runtime" } +sc-executor = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-core = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-keystore = { version = "0.13.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-state-machine = { version = "0.13.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-tracing = { version = "6.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-trie = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } + +[dev-dependencies] +criterion = "0.3.0" +futures = "0.3.21" +wat = "1.0" +frame-support = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +frame-system = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +node-testing = { version = "3.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-balances = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-contracts = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-im-online = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-sudo = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-timestamp = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-treasury = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-transaction-payment = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-application-crypto = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-root-testing = { version = "1.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-consensus-babe = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-externalities = { version = "0.13.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-keyring = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-runtime = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } + +[features] +stress-test = [] \ No newline at end of file diff --git a/node/executor/src/lib.rs b/node/executor/src/lib.rs new file mode 100644 index 0000000..c00af71 --- /dev/null +++ b/node/executor/src/lib.rs @@ -0,0 +1,37 @@ +// This file is part of Substrate. + +// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! A `CodeExecutor` specialization which uses natively compiled runtime when the wasm to be +//! executed is equivalent to the natively compiled code. + +pub use sc_executor::NativeElseWasmExecutor; + +// Declare an instance of the native executor named `ExecutorDispatch`. Include the wasm binary as +// the equivalent wasm code. +pub struct ExecutorDispatch; + +impl sc_executor::NativeExecutionDispatch for ExecutorDispatch { + type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions; + + fn dispatch(method: &str, data: &[u8]) -> Option> { + xsocial_runtime::api::dispatch(method, data) + } + + fn native_version() -> sc_executor::NativeVersion { + xsocial_runtime::native_version() + } +} diff --git a/node/primitives/Cargo.toml b/node/primitives/Cargo.toml new file mode 100644 index 0000000..e8a60ed --- /dev/null +++ b/node/primitives/Cargo.toml @@ -0,0 +1,34 @@ +[package] +name = "node-primitives" +version = "2.0.0" +authors = ["Parity Technologies "] +description = "Substrate node low-level primitives." +edition = "2021" +license = "Apache-2.0" +homepage = "https://substrate.io" +repository = "https://github.com/paritytech/substrate/" +publish = false + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false, features = [ + "derive", +] } +scale-info = { version = "2.1.1", default-features = false, features = ["derive"] } +frame-system = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-application-crypto = { version = "7.0.0", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-core = { version = "7.0.0", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-runtime = { version = "7.0.0", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } + +[features] +default = ["std"] +std = [ + "codec/std", + "frame-system/std", + "scale-info/std", + "sp-application-crypto/std", + "sp-core/std", + "sp-runtime/std", +] diff --git a/node/primitives/src/lib.rs b/node/primitives/src/lib.rs new file mode 100644 index 0000000..feb9ee6 --- /dev/null +++ b/node/primitives/src/lib.rs @@ -0,0 +1,66 @@ +// This file is part of Substrate. + +// Copyright (C) 2018-2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! Low-level types used throughout the Substrate code. + +#![warn(missing_docs)] +#![cfg_attr(not(feature = "std"), no_std)] + +use sp_runtime::{ + generic, + traits::{BlakeTwo256, IdentifyAccount, Verify}, + MultiSignature, OpaqueExtrinsic, +}; + +/// An index to a block. +pub type BlockNumber = u32; + +/// Alias to 512-bit hash when used in the context of a transaction signature on the chain. +pub type Signature = MultiSignature; + +/// Some way of identifying an account on the chain. We intentionally make it equivalent +/// to the public key of our transaction signing scheme. +pub type AccountId = <::Signer as IdentifyAccount>::AccountId; + +/// The type for looking up accounts. We don't expect more than 4 billion of them. +pub type AccountIndex = u32; + +/// Balance of an account. +pub type Balance = u128; + +/// Type used for expressing timestamp. +pub type Moment = u64; + +/// Index of a transaction in the chain. +pub type Index = u32; + +/// A hash of some data used by the chain. +pub type Hash = sp_core::H256; + +/// A timestamp: milliseconds since the unix epoch. +/// `u64` is enough to represent a duration of half a billion years, when the +/// time scale is milliseconds. +pub type Timestamp = u64; + +/// Digest item type. +pub type DigestItem = generic::DigestItem; +/// Header type. +pub type Header = generic::Header; +/// Block type. +pub type Block = generic::Block; +/// Block ID. +pub type BlockId = generic::BlockId; diff --git a/node/res/xsocial.json b/node/res/xsocial.json deleted file mode 100644 index 9932900..0000000 --- a/node/res/xsocial.json +++ /dev/null @@ -1,1055 +0,0 @@ -{ - "name": "XSocial Testnet", - "id": "xsocial_testnet", - "chainType": "Live", - "bootNodes": [], - "telemetryEndpoints": [ - [ - "/dns/telemetry.polkadot.io/tcp/443/x-parity-wss/%2Fsubmit%2F", - 0 - ] - ], - "protocolId": "sub-xsocial-v0", - "properties": { - "ss58Format": 28, - "tokenDecimals": 10, - "tokenSymbol": "SUB" - }, - "codeSubstitutes": {}, - "genesis": { - "raw": { - "top": { - "0x22b42e0b5063ee90848a8a42dca755294e7b9012096b41c4eb3aaf947f6ea429": "0x0000", - "0x26aa394eea5630e07c48ae0c9558cef74e7b9012096b41c4eb3aaf947f6ea429": "0x0000", - "0x26aa394eea5630e07c48ae0c9558cef75684a022a34dd8bfa2baaf44f172b710": "0x01", - "0x26aa394eea5630e07c48ae0c9558cef78a42f33323cb5ced3b44dd825fda9fcc": "0x4545454545454545454545454545454545454545454545454545454545454545", - "0x26aa394eea5630e07c48ae0c9558cef7a44704b568d21667356a5a050c118746b4def25cfda6ef3a00000000": "0x4545454545454545454545454545454545454545454545454545454545454545", - "0x26aa394eea5630e07c48ae0c9558cef7a7fd6c28836b9a28522dc924110cf439": "0x01", - "0x26aa394eea5630e07c48ae0c9558cef7b99d880ec681799c0cf30e8886371da9cb57c70ef83699051944b7b796a4ca3da8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45": "0x000000000000000001000000000000000000c16ff28623000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "0x26aa394eea5630e07c48ae0c9558cef7f9cce9c888469bb1a0dceaa129672ef8": "0x91011c78736f6369616c", - "0x3a636f6465": "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", - "0x3a65787472696e7369635f696e646578": "0x00000000", - "0x3a6772616e6470615f617574686f726974696573": "0x0108419c48625508cc74c8c125dd0132158d3583b479975e516c3c2cc1457d11a7c50100000000000000b553650f5032ecadba5df3bd35e8d280bc6f5cdff1beda8c504d6cfecc89c63a0100000000000000", - "0x3f1467a096bcd71a5b6a0c8155e20810308ce9615de0775a82f8a94dc3d285a1": "0x01", - "0x3f1467a096bcd71a5b6a0c8155e208103f2edf3bdf381debe331ab7446addfdc": "0x000064a7b3b6e00d0000000000000000", - "0x3f1467a096bcd71a5b6a0c8155e208104e7b9012096b41c4eb3aaf947f6ea429": "0x0000", - "0x57f8dc2f5ab09467896f47300f0424384e7b9012096b41c4eb3aaf947f6ea429": "0x0000", - "0x57f8dc2f5ab09467896f47300f0424385e0621c4869aa60c02be9adcc98a0d1d": "0x08d4f4482d82913b5a4ef195bba7ec5567ee04b6ea784139c04ee5e77530670149640f97526d653b620d1ccbdefa4cb212cc0dfc76f77a0f631f96f009d986464b", - "0x5c0d1176a568c1f92944340dbfed9e9c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", - "0x5c0d1176a568c1f92944340dbfed9e9c530ebca703c85910e7164cb7d1c9e47b": "0xa8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45", - "0x5f9cc45b7a00c5899361e1c6099678dc4e7b9012096b41c4eb3aaf947f6ea429": "0x0400", - "0x5f9cc45b7a00c5899361e1c6099678dc8a2d09463effcc78a22d75b9cb87dffc": "0x0000000000000000", - "0x5f9cc45b7a00c5899361e1c6099678dcd47cb8f5328af743ddfb361e7180e7fcbb1bdbcacd6ac9340000000000000000": "0x00000000", - "0xa31f5a5260e78d7df27950c13d40704c4e7b9012096b41c4eb3aaf947f6ea429": "0x0000", - "0xbd2a529379475088d3e29a918cd478724e7b9012096b41c4eb3aaf947f6ea429": "0x0000", - "0xc2261276cc9d1f8598ea4b6a74b15c2f4e7b9012096b41c4eb3aaf947f6ea429": "0x0100", - "0xc2261276cc9d1f8598ea4b6a74b15c2f57c875e4cff74148e4628f264b974c80": "0x0000c16ff28623000000000000000000", - "0xc2b6ac49ee131be4de5527a2ccab4a674e7b9012096b41c4eb3aaf947f6ea429": "0x0000", - "0xcc98f986f653d94b4d47ed05aa4522194e7b9012096b41c4eb3aaf947f6ea429": "0x0000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332100f527e678449dd0f100000000000000": "0xf100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321014cbc17139b3d926702000000000000": "0x6702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321016e8f5b868e2bca6c01000000000000": "0x6c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332101fa6b2a2461b71ff801000000000000": "0xf801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321023723973fb9bea37301000000000000": "0x7301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210268f57373d4ff3c0902000000000000": "0x0902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210349a011341eed9a0600000000000000": "0x0600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321039fdf88337e2f034600000000000000": "0x4600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332103bb01328092cd10dd01000000000000": "0xdd01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210402741d9c3b1c6b1a03000000000000": "0x1a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210470dd70e52b302f2003000000000000": "0x2003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332104ad0e1944ef9568dc03000000000000": "0xdc03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332105734c99d41b6da7de02000000000000": "0xde02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210597ef7a778d51141701000000000000": "0x1701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210599f1b0e0c174562001000000000000": "0x2001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332105aec83a3ed8843dfd02000000000000": "0xfd02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332105be9b3941f8ea277f03000000000000": "0x7f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332106142cd69486b73b3f00000000000000": "0x3f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210627acba370b41a1ab03000000000000": "0xab03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321062daa518e0fcb56ad00000000000000": "0xad00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210645be279ea025975703000000000000": "0x5703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210666f3a9b6889f083803000000000000": "0x3803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210698271bc9c5d94fa000000000000000": "0xa000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332107aed72891886db09003000000000000": "0x9003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332107b75db3e3985cb70d02000000000000": "0x0d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332107c49cc041e06aac8300000000000000": "0x8300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332107dd1e9a9b10c6bc0803000000000000": "0x0803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332107e3a8cb90f303c3c701000000000000": "0xc701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321085c71218f72091d5d02000000000000": "0x5d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332108c0254bb52d4e807b02000000000000": "0x7b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332108cdd69027a0a6747a01000000000000": "0x7a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210901e4ef315cf20e7001000000000000": "0x7001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210925d6a980f243b95f03000000000000": "0x5f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321093e2ade1f3bc5db8602000000000000": "0x8602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210961260c772739bdcb03000000000000": "0xcb03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210963eafefec0ab6a3c03000000000000": "0x3c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210971d2f0821f235cfc00000000000000": "0xfc00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321098eb895db2c69129800000000000000": "0x9800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210990f147ade5e8e9c902000000000000": "0xc902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332109b30a202c3ddd2e9d02000000000000": "0x9d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332109d40792b3d38191ba03000000000000": "0xba03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332109d74605c153e24f6f03000000000000": "0x6f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a0029fea3d318c2ac00000000000000": "0xac00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a1e16744fdd9a1c0002000000000000": "0x0002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a28905153c8d9622303000000000000": "0x2303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a50cbf184f648993e03000000000000": "0x3e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a59ed87828062710303000000000000": "0x0303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210a72b2109d3b9ad8c700000000000000": "0xc700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210b091b5a339fe9ff8e03000000000000": "0x8e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210b77c4f216fe975abb03000000000000": "0xbb03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210b9b7c2374d1ed275b01000000000000": "0x5b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210baa3fa201cb7f548403000000000000": "0x8403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210c1d3ad0589a29a78000000000000000": "0x8000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210c4330def9ebd14a3703000000000000": "0x3703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210c6db1ad6dc7331a4402000000000000": "0x4402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210ce9fbe9f08c4294e601000000000000": "0xe601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210cfaeacc491573ad6001000000000000": "0x6001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210d4d4083a87d257ce801000000000000": "0xe801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210d88aacecf92646d1b01000000000000": "0x1b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210e2234a0e58c0150a101000000000000": "0xa101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210eafef985ba61d976202000000000000": "0x6202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210efb6b72d553e415df02000000000000": "0xdf02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210efb6bd85c58cd106a02000000000000": "0x6a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210f00488539b7a6a7d602000000000000": "0xd602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210f2563426d99be212a01000000000000": "0x2a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210f5de6380c21e6fb6802000000000000": "0x6802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210f5e0a10cbce516d7303000000000000": "0x7303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33210fb45163014518033003000000000000": "0x3003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332110b1ef8e726bc48b6002000000000000": "0x6002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321110cfcd5eb55e9e62103000000000000": "0x2103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332111434190a0e85a126703000000000000": "0x6703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321114e7435772b4f75ea01000000000000": "0xea01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321116e5e0702e35fb96e00000000000000": "0x6e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211191a1ff026ffceb6d02000000000000": "0x6d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332111bb383051a7fcb09600000000000000": "0x9600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332111cb28a718a6dfb98901000000000000": "0x8901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332111e1d47c7bedfa485a03000000000000": "0x5a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332111f32d9aa0abc6e05f02000000000000": "0x5f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211206bc4d032894a81c00000000000000": "0x1c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321122ed5bd1dd475121503000000000000": "0x1503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321124cf5ab9c606b441d02000000000000": "0x1d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211291d7f46d122bf3bc01000000000000": "0xbc01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332112b8a498d564d2456c03000000000000": "0x6c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332112bb5650a0e73cb4fb00000000000000": "0xfb00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332112c0f2f553de1f16b501000000000000": "0xb501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321136c4064f0f68f654900000000000000": "0x4900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332113994971f5e753a49a00000000000000": "0x9a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321139a57f04a423a3ecb02000000000000": "0xcb02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332113a8d4384914250ed302000000000000": "0xd302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211455fc9a4811ffaed502000000000000": "0xd502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332114fb739b8333fd539601000000000000": "0x9601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332115391d26cd0f8e971303000000000000": "0x1303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321157b13af9d750777d000000000000000": "0xd000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332115bfc7c35fce3aa69200000000000000": "0x9200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332115c4ea6eef6663fb7202000000000000": "0x7202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332115f5478a4898eefa9501000000000000": "0x9501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332116efcce1ce9f16d6bd02000000000000": "0xbd02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321173591d7eb1b06693e02000000000000": "0x3e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321179041b8a624120fd102000000000000": "0xd102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211795ca862faec0dc3e00000000000000": "0x3e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332117c4ce9ec6fcb0a64b00000000000000": "0x4b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332118d4fdcb6d97cda51100000000000000": "0x1100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332118d66624a82f8ce64a02000000000000": "0x4a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332118fd021b99698289ac03000000000000": "0xac03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321192cb54b38e305c9d401000000000000": "0xd401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332119371f0b8eb58cfc0901000000000000": "0x0901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321195443923204c265e502000000000000": "0xe502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321198e9190d2a46f734803000000000000": "0x4803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211a1b3e04e244cde33501000000000000": "0x3501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211a4ca3d2f48bb41b2603000000000000": "0x2603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211a7595a63ca78fe6d501000000000000": "0xd501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211a8f8f0aefd526adb700000000000000": "0xb700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211ab1297d84b5a28f0103000000000000": "0x0103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211bac7511b33e8417ba01000000000000": "0xba01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211bc328bf9be0ce6ef700000000000000": "0xf700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211c478eeb0d5416db7e03000000000000": "0x7e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211dae9e3480e087673c01000000000000": "0x3c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211dc20f920c5874633802000000000000": "0x3802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211ddc5c258ceb41cb6701000000000000": "0x6701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211df5194bbb9a7719c300000000000000": "0xc300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211df7fde8e0ffb6104903000000000000": "0x4903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211e096e9f7cf70a9dd100000000000000": "0xd100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211e30680c6c0058793a02000000000000": "0x3a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211e5814b1935f0590a202000000000000": "0xa202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211e6afb12afa810e50403000000000000": "0x0403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211ede9b9f5ad25163bf00000000000000": "0xbf00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211f2514a57b3c2045b102000000000000": "0xb102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211f353ce9fd6e55172100000000000000": "0x2100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211fa7eaa95441943a2400000000000000": "0x2400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211fd02315cea3c63ad403000000000000": "0xd403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33211ff0db6ff76a2e96c203000000000000": "0xc203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332120d23dec54669123ae03000000000000": "0xae03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321210d292d3d5908e90101000000000000": "0x0101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321215114c642fa12de7300000000000000": "0x7300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212159bae8d0723c3b8103000000000000": "0x8103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332121a7ae0520deb00b6a00000000000000": "0x6a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332121bcf2f351133e974d00000000000000": "0x4d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332121e2daadea7f5dd03101000000000000": "0x3101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321221afeed29bdac66ac02000000000000": "0xac02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321224ffc5308e5c40e5300000000000000": "0x5300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332122581317f09f86134e01000000000000": "0x4e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332122cfc34745705b180a00000000000000": "0x0a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332122deaf27467121b0b100000000000000": "0xb100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321234c02bf6c5459854c00000000000000": "0x4c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332123ae5c0d39d9e338f202000000000000": "0xf202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212439d5a77e274dae3a03000000000000": "0x3a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212451a40f66b53ff01e01000000000000": "0x1e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212465d69326de41f83d03000000000000": "0x3d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332124bc857f8ad35c629402000000000000": "0x9402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321251b1f5223922e204902000000000000": "0x4902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321258badbf34cb04769203000000000000": "0x9203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332125d1fb30c2029a523d02000000000000": "0x3d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332125d712aba4c4a50efa01000000000000": "0xfa01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212600c8393d63e82ce401000000000000": "0xe401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321261ecf14163a0dd45602000000000000": "0x5602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212648c23e4f84aeaf2c01000000000000": "0x2c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212667c50999720e85d203000000000000": "0xd203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321266b83bfb98ff6925b03000000000000": "0x5b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332126760b9a3d753b387601000000000000": "0x7601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321271f06de3f2150298a01000000000000": "0x8a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321277c52a11fadf5753900000000000000": "0x3900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321277dd0eb513b406f5102000000000000": "0x5102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321280766a42c408a514b02000000000000": "0x4b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212817d58bb7552e4be002000000000000": "0xe002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212858f306143eb116bd01000000000000": "0xbd01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321290b02fdb1d3b6c78c01000000000000": "0x8c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321291577b449b5ee83e102000000000000": "0xe102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332129ab61e2736e19099902000000000000": "0x9902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332129f024a69d0b190bfe01000000000000": "0xfe01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212a44911af53be0713f03000000000000": "0x3f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212a50ebf8862552621600000000000000": "0x1600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212adc162cfa496fceb202000000000000": "0xb202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b487ef7f1532a6ecc03000000000000": "0xcc03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b4a43bf42bd300c9302000000000000": "0x9302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b5abcdef0e7cd87e003000000000000": "0xe003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b6dfa2999cd6d3fc801000000000000": "0xc801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b705d7c8f1976650c03000000000000": "0x0c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212b8d936ed1c74e3b0a03000000000000": "0x0a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212c0bd437670ed7af6603000000000000": "0x6603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212c285637a2a45b198900000000000000": "0x8900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212ca3af29fc20a6fe6201000000000000": "0x6201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212cec332c92bfe0296d00000000000000": "0x6d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212d3947acf6aa8347d300000000000000": "0xd300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212d4cde4944654bd01e03000000000000": "0x1e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212dbdf2750b2eb3189f03000000000000": "0x9f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212e08d563f4d232bba701000000000000": "0xa701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212e31413c2341cc87f802000000000000": "0xf802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212e320f73ec383afe8f03000000000000": "0x8f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212e5bf915e7f3b8768f02000000000000": "0x8f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212f56e5005e118546b703000000000000": "0xb703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33212fda93ebbd8b89f2a100000000000000": "0xa100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321300635051113bb426502000000000000": "0x6502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321300cb436f4d09ff36b00000000000000": "0x6b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321302fe276d44fffb24301000000000000": "0x4301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321305e8ca811d65a0adf01000000000000": "0xdf01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332130b9de03fa5963d90001000000000000": "0x0001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332130cd467b4f58c59e5a00000000000000": "0x5a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321318d761d0eca4c7c5803000000000000": "0x5803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332131a631a46a9ff78ca702000000000000": "0xa702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332131da77d497250b797b01000000000000": "0x7b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332131fb44d9d74eb7b79f01000000000000": "0x9f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321320a04fab7be95873300000000000000": "0x3300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321320f62ffe8f27a3eef00000000000000": "0xef00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132497a2b8fc9d85fa503000000000000": "0xa503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132b010cc535cefe9d003000000000000": "0xd003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132c977c95d2ca3652b01000000000000": "0x2b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132df4a9b227fe64f8503000000000000": "0x8503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132ecbaedcaea8fe01b02000000000000": "0x1b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332132fc9237102ed443b301000000000000": "0xb301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332133313fa8e5bf443f1102000000000000": "0x1102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332133805ba2ef00a872e503000000000000": "0xe503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321338f735fcddf5eb86f01000000000000": "0x6f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321339305e0836977655a02000000000000": "0x5a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332133c05c8699d0b83c3a00000000000000": "0x3a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332133d512ebf46134033503000000000000": "0x3503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213469c54e8cb035fd2501000000000000": "0x2501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213476069ad9d6cf232402000000000000": "0x2402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332134a31bcc4026bb35d200000000000000": "0xd200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332134b9cf520b3a72facd00000000000000": "0xcd00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332135ffab14b86311adfc01000000000000": "0xfc01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321365e51413fe96b300701000000000000": "0x0701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332136edb8a5e921abd52201000000000000": "0x2201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321370a179fcbeaed6ff601000000000000": "0xf601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213780a7002d1441847402000000000000": "0x7402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321382beaa3e0126a64b101000000000000": "0xb101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321385a7c9189ec3ef56503000000000000": "0x6503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332138735139f5ec7bdbed00000000000000": "0xed00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332138d630687d0b8043df00000000000000": "0xdf00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332138f983c96fa07e8b6c00000000000000": "0x6c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321393c986bf9f3d0468301000000000000": "0x8301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213955b1c81ec29ffa2800000000000000": "0x2800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213958af96072638e07901000000000000": "0x7901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213995dad07cbfa5a80c00000000000000": "0x0c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332139c7151c9953b8c7c702000000000000": "0xc702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213a76cd24b2006f31b401000000000000": "0xb401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213a8dd62119c6aa109d03000000000000": "0x9d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213b41a50021d39eb9cf00000000000000": "0xcf00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213b497aadda7841567502000000000000": "0x7502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213b7edcbd7eaf2e7de802000000000000": "0xe802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213c201a3ec20429352503000000000000": "0x2503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213c26619616d20379f702000000000000": "0xf702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213c543ab4f6eb65d02c02000000000000": "0x2c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213ca24ea29258da146601000000000000": "0x6601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213cd4d9891d52f2595403000000000000": "0x5403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213cdb013f6c570e44c802000000000000": "0xc802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213ceae3e27dc4313d1900000000000000": "0x1900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d2065b4917515953700000000000000": "0x3700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d24d187ecfe56c7c001000000000000": "0xc001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d2b6c6e36aa26c25f01000000000000": "0x5f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d345cc367f497b1a300000000000000": "0xa300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d3c91bde13c2a550b02000000000000": "0x0b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d59c2d52d0bbe890500000000000000": "0x0500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213d5d7a338175da4b2802000000000000": "0x2802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213e4b28e5094809635f00000000000000": "0x5f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213ef1ca0a392a5c275802000000000000": "0x5802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213f6023e6df6aa02aff00000000000000": "0xff00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33213fd036fcab4bbf624702000000000000": "0x4702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321407ad79c61e41d6fe602000000000000": "0xe602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321408f6b430ab072206f02000000000000": "0x6f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332140a9acf4c9602a793102000000000000": "0x3102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321410e1122416567d2d902000000000000": "0xd902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332141154d73bae6fb995c02000000000000": "0x5c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332141426c31b15c8fe21c02000000000000": "0x1c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214148eca76d16b8870300000000000000": "0x0300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214275c7ba75a8dd931700000000000000": "0x1700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321427618a74bcded14ca01000000000000": "0xca01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332142ebe09f792ca84c0e00000000000000": "0x0e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332142fde0e95415eb62ff01000000000000": "0xff01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321437475f33024ff040d00000000000000": "0x0d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321438ae91e4b411aceb903000000000000": "0xb903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332143a0673a1700f1685103000000000000": "0x5103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332143e084f4cb631cf3a402000000000000": "0xa402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321440e4ae272346968f201000000000000": "0xf201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321449501768c52f705d303000000000000": "0xd303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332144d13d131a792399c201000000000000": "0xc201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332144df452ba38e01e39c02000000000000": "0x9c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332144fa244f82e95fa3c401000000000000": "0xc401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214549f27afbed5042be03000000000000": "0xbe03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321456f7e3c7ea412be5402000000000000": "0x5402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332145efe567a97880592d00000000000000": "0x2d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332146103834e980e5c92600000000000000": "0x2600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321463729b795ab910f9b03000000000000": "0x9b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214641cff150196278ce00000000000000": "0xce00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214658612a8b06aa047e00000000000000": "0x7e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321469bcbea67835b714b01000000000000": "0x4b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332146c50c7aa08e4c06e101000000000000": "0xe101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332146d4f2a789e1ffcba902000000000000": "0xa902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321478545fcc72f01318803000000000000": "0x8803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332147c35e051acca3529d01000000000000": "0x9d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321480a83a5d6f761917803000000000000": "0x7803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214810122ff0a3cbbfd001000000000000": "0xd001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332148682ae90e82eb67b902000000000000": "0xb902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321487e27ef2eb8e7ca4303000000000000": "0x4303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321496333e57d2bbfd4da00000000000000": "0xda00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321499a6c87222d3fe5e803000000000000": "0xe803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321499ac0b5b8bbae27a800000000000000": "0xa800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332149cf49b35eecb82c8702000000000000": "0x8702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214a3a545792a96255d803000000000000": "0xd803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214a621d4ae264efd9dd02000000000000": "0xdd02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214aa9a36683861ae67e02000000000000": "0x7e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214abfa797deaafc0c6301000000000000": "0x6301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214b2fe67da3498910e603000000000000": "0xe603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214c195cb97731ce7d6500000000000000": "0x6500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214c3c66260a77e3531101000000000000": "0x1101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214c5857f7051a0a39e800000000000000": "0xe800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214c65ef5594bda4846902000000000000": "0x6902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214c75308a323b74702a02000000000000": "0x2a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214cbcff36cff93d9c8002000000000000": "0x8002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214ceac484714766e7b803000000000000": "0xb803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214d1a715bead5d5044403000000000000": "0x4403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214d3a04ec3457e861dd00000000000000": "0xdd00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214d64a3445280429cff02000000000000": "0xff02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214dd38f46c9bfed8e0603000000000000": "0x0603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214e24ac59698cb4f20800000000000000": "0x0800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214e6b062fcebd37bc9a02000000000000": "0x9a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214f1b4c97d21d3902fa02000000000000": "0xfa02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214f5cce6d93da4129c102000000000000": "0xc102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214f6b83b6d9d3e7d38102000000000000": "0x8102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214f72ec67dce29af47102000000000000": "0x7102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214f73f9cf6b19dcc85002000000000000": "0x5002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214fca4cb035ea49795302000000000000": "0x5302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33214fd06dfcc1fd58d25a01000000000000": "0x5a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332150eb9b636bda43607a03000000000000": "0x7a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332150f7a4523e93dbe0d600000000000000": "0xd600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215103bd9ba69515198a02000000000000": "0x8a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321511ead6239a439d96403000000000000": "0x6403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332151350afbf9f16e2f3602000000000000": "0x3602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332151c38fc0a8bc4897b203000000000000": "0xb203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321523875990d56f2d40502000000000000": "0x0502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321526ee91b8b3cd8251d01000000000000": "0x1d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215278a13a545710341f03000000000000": "0x1f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332152fb5595e0a3314cd702000000000000": "0xd702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215343d1b66f8056b52a00000000000000": "0x2a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332153eb37cb9f8606451f02000000000000": "0x1f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321540c35dba9765feccf01000000000000": "0xcf01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321548736d6bc9abf49cd01000000000000": "0xcd01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332154bcbda5c12e06014a00000000000000": "0x4a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332154c22ea28bd0c0dd4101000000000000": "0x4101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321551aabf1b3e3a8da3702000000000000": "0x3702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215555fa73093fa5a93403000000000000": "0x3403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332155709dd9b875a63a5d03000000000000": "0x5d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321557a13668d86eedbfa00000000000000": "0xfa00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332155e4fd6a40cd76080700000000000000": "0x0700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332156531103b3a002d73603000000000000": "0x3603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321571deabf2557dfc5ad02000000000000": "0xad02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321575519e2c5e4d0a9b001000000000000": "0xb001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215774f4008503726ea903000000000000": "0xa903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332157c445ec623c69f66d01000000000000": "0x6d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215801df91cf1530403100000000000000": "0x3100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321580a8bcaa2063eeae700000000000000": "0xe700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321582546570b1e5c6f1103000000000000": "0x1103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321583264242e08b658be02000000000000": "0xbe02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332158673825653c962c3e01000000000000": "0x3e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321587da4540af6276bc502000000000000": "0xc502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332158c1a279f846588b1703000000000000": "0x1703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332158c4a70573b6a0e61f00000000000000": "0x1f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215928dcc6901f246db702000000000000": "0xb702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321592a90ee9536ce99e400000000000000": "0xe400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321597d500c272aeeebc800000000000000": "0xc800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215a25fdf7cb7c62f7eb01000000000000": "0xeb01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215a4a66d80f6e679ea102000000000000": "0xa102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215a9aa2d47d65e191bb02000000000000": "0xbb02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215adf1a16cf4775c24701000000000000": "0x4701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215b04c92d4f30c5052e02000000000000": "0x2e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215b35a2d533ef39a08b03000000000000": "0x8b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215b4caf61c442a1a4f400000000000000": "0xf400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215bb7114a59e1574e4602000000000000": "0x4602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215bb7ad8b4fd0fd634302000000000000": "0x4302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215bc7c5fd0f633d441201000000000000": "0x1201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215c7abdb05ddb7ae86101000000000000": "0x6101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215c98370106ffd69cad01000000000000": "0xad01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215d23c4babf810f7ce402000000000000": "0xe402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215d772bdda79b2c566b01000000000000": "0x6b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215d7f268015bd5a67a302000000000000": "0xa302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215da817addd722b9f9a03000000000000": "0x9a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215de4a730373baee1c303000000000000": "0xc303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215e80f4afc634f05eef02000000000000": "0xef02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215ea8a9a01b3fb552ab00000000000000": "0xab00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215eed97c08ff9f8e5a002000000000000": "0xa002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215efe29c2558ffe722a03000000000000": "0x2a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215f3bb3cb13aff9cf6b02000000000000": "0x6b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215f43ad3f8d3383f9c002000000000000": "0xc002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33215f6dc50e853f177f5503000000000000": "0x5503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321605cb1a64e2456dc9103000000000000": "0x9103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321608b2ed0ece55eacb701000000000000": "0xb701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332161291dfa3f5cea782701000000000000": "0x2701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321612d7c24647a931e0f03000000000000": "0x0f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321613700e5ee6d8b327f00000000000000": "0x7f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216152dc7e51742f9bba00000000000000": "0xba00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332161690a8517e5e2be2d02000000000000": "0x2d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216179a086b72127e56b03000000000000": "0x6b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332161f8d0a83b6e48e97302000000000000": "0x7302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216226b79dd45e4bc24e03000000000000": "0x4e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321624188c0d92477599001000000000000": "0x9001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216264fa86046f1e414d02000000000000": "0x4d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332162699aa57da216e0e301000000000000": "0xe301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332162abe5c68b5dce3de203000000000000": "0xe203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332162e44a2270679c1e9502000000000000": "0x9502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332163154cba480f25c38600000000000000": "0x8600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321632f25d10c90de9ac602000000000000": "0xc602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321636ccae8e7ceac1c7c03000000000000": "0x7c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321638742a1b96bbd5ef901000000000000": "0xf901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332163a9b3a3eac94f4e3402000000000000": "0x3402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332163e579b7c8311ee09301000000000000": "0x9301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321641e7004d0ce32027d02000000000000": "0x7d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321644882942b79816b4000000000000000": "0x4000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321644fa0c536240b9d4d01000000000000": "0x4d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332164671a5d3c56dd6c4501000000000000": "0x4501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216511b75bc59b5da9e100000000000000": "0xe100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332165c3739859ae3ee01002000000000000": "0x1002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332165f4b9479eb671fc4a03000000000000": "0x4a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216644fdb82aa2f7936e02000000000000": "0x6e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332166776c0a6ddef5b23502000000000000": "0x3502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332166f8b173e282bed9fb02000000000000": "0xfb02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332167ae7f0a8e5040510b01000000000000": "0x0b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332167c5e26395ac30a7ab02000000000000": "0xab02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216808afb4771f54a48302000000000000": "0x8302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321680f0cb6825297207903000000000000": "0x7903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321682e924452d5514a2203000000000000": "0x2203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332168f492c97d2b39f7aa01000000000000": "0xaa01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216a29b535b30fafc9ac01000000000000": "0xac01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216ae2dc69d7df92c9fe00000000000000": "0xfe00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216b02308cb80992b8ec02000000000000": "0xec02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216bcf6e6b1c8dfc250501000000000000": "0x0501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216c5836ddb821f4b4ea00000000000000": "0xea00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216c78df2c4542c7cca403000000000000": "0xa403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216c7faede5e7d3e672f02000000000000": "0x2f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216cf74fa0be5d030fe001000000000000": "0xe001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216d30aa37d49d892a9b00000000000000": "0x9b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216d3847e23b24dd7c2b02000000000000": "0x2b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216d6c3fe0517fcae64703000000000000": "0x4703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216d72680a04245cc09102000000000000": "0x9102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216d79bd915a49ee691a01000000000000": "0x1a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216dc9bd32090cf7934e00000000000000": "0x4e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216e28b94bbd691ec77101000000000000": "0x7101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216ef1ad264fd6f28dc402000000000000": "0xc402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216f204c0bf41378dbb300000000000000": "0xb300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216f372e6984eb562f9f02000000000000": "0x9f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216fd21a0b40ae5fa77100000000000000": "0x7100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216fda5424bf7f270d1802000000000000": "0x1802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33216ff52536e43c14fa8e00000000000000": "0x8e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217059cbc5776722ffb901000000000000": "0xb901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321705ea5514a551f06a703000000000000": "0xa703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217079b0b54b2b6967cb00000000000000": "0xcb00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332170ac3beea03077524802000000000000": "0x4802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217148994bd857d9ac5203000000000000": "0x5203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217189aee734dd3c015303000000000000": "0x5303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332171b9dff0311471c5e302000000000000": "0xe302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217209eb482c58fcf1da03000000000000": "0xda03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321720f3db03c1656c44901000000000000": "0x4901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321721f9466891c501c2703000000000000": "0x2703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332172261bfb90131180b801000000000000": "0xb801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217280a2f3a49ed06bd802000000000000": "0xd802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321728b299207fe86029602000000000000": "0x9602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217294404b094ed48da303000000000000": "0xa303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217347bf132afeb9644b03000000000000": "0x4b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321737fd76268c213722300000000000000": "0x2300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332173cfed14b3ee0c588203000000000000": "0x8203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321741c779bb16404ac8200000000000000": "0x8200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332175389c626bd39c2a6800000000000000": "0x6800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332175fd31fedc867909a803000000000000": "0xa803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321768cae3cf77c62089701000000000000": "0x9701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332176b0689ceeacc6790801000000000000": "0x0801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217711efa8f93cc4375e00000000000000": "0x5e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332177136c612e5edef95201000000000000": "0x5201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321773c7f98b1b7fb0e5501000000000000": "0x5501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332177b86242480f8d10da02000000000000": "0xda02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332177eaf275b3f0d46fb500000000000000": "0xb500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321780485b0033b96431401000000000000": "0x1401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321785e1defccaa4522e900000000000000": "0xe900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321786810de53969faea501000000000000": "0xa501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332178700b8b6cb34869b603000000000000": "0xb603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217958e07e3af956c10201000000000000": "0x0201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321797b8c7bc8d473c5eb02000000000000": "0xeb02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332179bdacc5a4b0dfa2c500000000000000": "0xc500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217a3054d45c9cdfa16400000000000000": "0x6400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217ac4b0128d8a4e637d00000000000000": "0x7d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217ad6995ccad481571601000000000000": "0x1601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217adc6b87596182a41003000000000000": "0x1003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217b06f1c98f5b75e71000000000000000": "0x1000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217b22fa3b957e62fcde00000000000000": "0xde00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217bbc449bbe44d1386203000000000000": "0x6203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217c36b843445381b9f800000000000000": "0xf800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217c8a06343ff946118601000000000000": "0x8601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217d43349323912c72d402000000000000": "0xd402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217d88164081ddff3c4e02000000000000": "0x4e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217db50ee987c110732b00000000000000": "0x2b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217e0987af4ba3cf66db01000000000000": "0xdb01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217e268756558e03ca6700000000000000": "0x6700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217e768a3d76eef074a700000000000000": "0xa700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217e83ddcd7fd6d6fbf401000000000000": "0xf401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217ec0eaa2c1367812bb01000000000000": "0xbb01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217ef93c6a4b40722ae701000000000000": "0xe701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217f104065706819c01b00000000000000": "0x1b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217f414cca110b27b91300000000000000": "0x1300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217fee25f1232a391a6401000000000000": "0x6401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33217ffbfdbac190e825c501000000000000": "0xc501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218068669580bc1b213903000000000000": "0x3903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218085cee7418c7f0e3601000000000000": "0x3601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332180a1e7faca58d064a400000000000000": "0xa400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332180e6d10c23c40948c403000000000000": "0xc403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332180e7289e7d27f9520601000000000000": "0x0601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332180f57eb1b1e0b209a200000000000000": "0xa200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332180f904c14fc769e94401000000000000": "0x4401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321812fff2a95919eb94c02000000000000": "0x4c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321814e3a291688fde6c901000000000000": "0xc901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321815dd087e3456858fd00000000000000": "0xfd00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332181dbc1f5dbbd7774be00000000000000": "0xbe00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332181f75d1000751b617201000000000000": "0x7201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321821db0e59d3ded058802000000000000": "0x8802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332182232755ec18e6847403000000000000": "0x7403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218242219df68294273103000000000000": "0x3103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332182501075cf2732283701000000000000": "0x3701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218271ff60a5611ab21a02000000000000": "0x1a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321827aeb206af6c509f500000000000000": "0xf500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332182e1661fa43185c78b00000000000000": "0x8b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332183103fd51f560c5dc903000000000000": "0xc903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321834f10001df291f24d03000000000000": "0x4d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321836295d721d6b0f17802000000000000": "0x7802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332183707d0484459e68de03000000000000": "0xde03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332183d2b377dea119895902000000000000": "0x5902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332183d5c2f4317f0ee0da01000000000000": "0xda01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321846d0b870628ca4f8701000000000000": "0x8701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321850dca8b74b65aa55801000000000000": "0x5801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218587319621db5b3c0402000000000000": "0x0402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332185982b9d581909bf5c03000000000000": "0x5c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332185ae5166ddef28d8e501000000000000": "0xe501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332185c340e498b59a95bc00000000000000": "0xbc00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332185c5bca6133e728cc200000000000000": "0xc200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332186018482963be8665c00000000000000": "0x5c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321871067d438f078f7d301000000000000": "0xd301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332187271c8d5598492a2900000000000000": "0x2900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321875306c7c9edbd735b02000000000000": "0x5b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332187bb1572d3bddee92301000000000000": "0x2301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332187bf13ae1f8619668902000000000000": "0x8902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218810eb5dc518eb395202000000000000": "0x5202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321881cbf4fbaaf95941801000000000000": "0x1801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332188a7c830f8d8bc917b00000000000000": "0x7b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332188d5337f8196a21e2e01000000000000": "0x2e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332188da8117dfb94bcdaf03000000000000": "0xaf03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332188e8b21caeffe0046801000000000000": "0x6801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218978510a7cda1edf3d01000000000000": "0x3d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321898711ca714d32b78101000000000000": "0x8101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218a054fe3e29b93665500000000000000": "0x5500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218a0a28433ef0a4425502000000000000": "0x5502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218a3e96be0a3bcf36f000000000000000": "0xf000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218a72715409fa27ca1902000000000000": "0x1902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218a7aeaf0b5e8d3327f01000000000000": "0x7f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218aa60d5397b53f1eb003000000000000": "0xb003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218ac2877b0a6a090f9300000000000000": "0x9300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218b5f30d881c24dd23800000000000000": "0x3800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218b8cac68df9338102403000000000000": "0x2403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218b9d58bf155ff9623600000000000000": "0x3600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218bd29707fa09a62b0400000000000000": "0x0400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218cb631b8aef80f80d701000000000000": "0xd701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218cc95d144a400cb10900000000000000": "0x0900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218cd8184be514a8648d03000000000000": "0x8d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218cdc5ba817b39d711702000000000000": "0x1702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218d3f7ae91d718f454200000000000000": "0x4200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218da13b42a44542f7b400000000000000": "0xb400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218dfbc059284ac1ea9000000000000000": "0x9000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218e20608034d6eece9702000000000000": "0x9702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218e65576f369634240802000000000000": "0x0802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218e7686c030fbc81e2e03000000000000": "0x2e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218e7c02ae93e3a4be8f01000000000000": "0x8f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218e94c3e8492814167400000000000000": "0x7400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218ea00e2e694eeea2c003000000000000": "0xc003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218eae950eb948f8d5c703000000000000": "0xc703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f09480a7a4cbd6d9c01000000000000": "0x9c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f0bf919754318839e03000000000000": "0x9e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f77fdbd32436bb6e600000000000000": "0xe600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f83a0c7f521719a5701000000000000": "0x5701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f8d27852c1f94a17800000000000000": "0x7800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218f926388df42f5dec400000000000000": "0xc400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218fa0e732e959e5e01501000000000000": "0x1501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33218fc45824979fcee3cc00000000000000": "0xcc00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321906d1ea75b3abbcd2e00000000000000": "0x2e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321906eda5870c6a721ce01000000000000": "0xce01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332190d1d6bf1bb6b9200b03000000000000": "0x0b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332191e53e8de0146bfa0f02000000000000": "0x0f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332191ed104ee5b589fd0203000000000000": "0x0203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219224c46ff6f22c545401000000000000": "0x5401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332192ff5c7c306c130b1403000000000000": "0x1403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321930fbdcbf0de9aedfd01000000000000": "0xfd01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332194a42bae69091f242d03000000000000": "0x2d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321950646a7ad8b98d42200000000000000": "0x2200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219571d8827e7b4473c100000000000000": "0xc100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321957a5b5992c073d42401000000000000": "0x2401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219599a4a217cb299f0100000000000000": "0x0100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332195f2d49c46c4474c7700000000000000": "0x7700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321961536a6bdca8d3c9d00000000000000": "0x9d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321963bdc2b3c367df2dc00000000000000": "0xdc00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332196da2de58783401e1500000000000000": "0x1500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332197418bad8f787e91ea02000000000000": "0xea02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219850f1db9f124713c202000000000000": "0xc202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332198d36b16df8acf017c02000000000000": "0x7c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332198ed111fd62f1b0bb103000000000000": "0xb103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332198f092f86ff393a72700000000000000": "0x2700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332198f1322f369447f4bf03000000000000": "0xbf03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332199119b7cd6bdc98d2002000000000000": "0x2002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f332199f3102fcabd3f82ae00000000000000": "0xae00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219a5e8d06d5e5a4189e00000000000000": "0x9e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219a65190b335dc8d83f01000000000000": "0x3f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219aff773c570c492d5d00000000000000": "0x5d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219b399d9112e98eba3b00000000000000": "0x3b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219be61526e15c05dfa103000000000000": "0xa103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219c407e22a00addbbaf01000000000000": "0xaf01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219c4ac1770ecd7720d601000000000000": "0xd601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219c81b8d1187ab8abd002000000000000": "0xd002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219c9d8659b9494409b201000000000000": "0xb201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219ce1693f212fed798402000000000000": "0x8402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219d4fd62469978471b303000000000000": "0xb303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219da28814e4ca3ac61f01000000000000": "0x1f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219dc5fd02c6ce53978903000000000000": "0x8903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219e2f97ad95ae09a14202000000000000": "0x4202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219e4f0f6e9bf1a8692b03000000000000": "0x2b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219e50f357826f45e2f302000000000000": "0xf302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219e686f84d73e7f21f200000000000000": "0xf200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219efe7697b5bc2ba44800000000000000": "0x4800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219f78bfd683725d1a5200000000000000": "0x5200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f33219fee9dde3abf8f3bbc02000000000000": "0xbc02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a0dc8ef9318991f1a802000000000000": "0xa802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a108aa656a694bf38500000000000000": "0x8500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a11bb227e066e7784a01000000000000": "0x4a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a1325cd6169073335100000000000000": "0x5100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a1375f8d1e9a0f852702000000000000": "0x2702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a13caa6ffd0066b26103000000000000": "0x6103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a1e051b66c93245e3200000000000000": "0x3200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a2428e1186bd987eba02000000000000": "0xba02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a2a2d80749dad8c89f00000000000000": "0x9f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a2e103f35280d9288d01000000000000": "0x8d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a316c502df4357d4d900000000000000": "0xd900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a384e3b95e5cc1121c01000000000000": "0x1c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a415cb2b1c7125ea8703000000000000": "0x8703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a442b46bef000beae703000000000000": "0xe703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a48ddb4d33788ec38f00000000000000": "0x8f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a4a6d4951ab49c228202000000000000": "0x8202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a552af5382a1839f5e03000000000000": "0x5e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a5766ea65a559bcd8502000000000000": "0x8502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a6341a62d99504b01d03000000000000": "0x1d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a65956accff48c9caa03000000000000": "0xaa03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a6c03fdf43ec7ccb8501000000000000": "0x8501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a6f838d506ba1bdd3500000000000000": "0x3500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a776f73c0a3377044500000000000000": "0x4500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a7c125c5d7022d154002000000000000": "0x4002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a7d83ead5f56295cec00000000000000": "0xec00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a7ea5b28732a88a95700000000000000": "0x5700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a7f6d990da69d20aee01000000000000": "0xee01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a7f8030f4d5907e0d801000000000000": "0xd801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a81ef511f33535aa5901000000000000": "0x5901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a883bbb52f32fb46b802000000000000": "0xb802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a8de377e9d95355dab01000000000000": "0xab01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a90125235baff7811203000000000000": "0x1203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a9e14f0aea6c38070702000000000000": "0x0702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a9f8eafccec4736d6803000000000000": "0x6803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321a9fbd841cb60dac11903000000000000": "0x1903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aa143f12a44b6231c603000000000000": "0xc603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aa1f8aa6506f32183b01000000000000": "0x3b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aa9b21d0d8e404818a00000000000000": "0x8a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aacaaa023976e9e1b601000000000000": "0xb601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aae8648a3175f5301200000000000000": "0x1200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ab0f4e27e01b9e696602000000000000": "0x6602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ab200f854ee38ae85903000000000000": "0x5903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ac69d31b92b6670cf300000000000000": "0xf300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321acc6c2007c49b311f701000000000000": "0xf701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ad37b33d93c01aad2502000000000000": "0x2502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ad78db0ebdce444c9b01000000000000": "0x9b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321adb9d50b48dd5cec9e01000000000000": "0x9e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321adf84446d908a2fba001000000000000": "0xa001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ae3bd5e58bd267c29802000000000000": "0x9802000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ae6eae5a91292f0cd603000000000000": "0xd603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ae7ff53dc243f3edb302000000000000": "0xb302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321aee697b633330518ed02000000000000": "0xed02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321af0d89300933caf4fc02000000000000": "0xfc02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321af4ee0531cdae6114700000000000000": "0x4700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321af8e89119099ad073a01000000000000": "0x3a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afb4be00c49b9304a602000000000000": "0xa602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afb784d894bf7632a301000000000000": "0xa301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afba43762858e7507501000000000000": "0x7501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afc9a87bb20f085a8b02000000000000": "0x8b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afca3faaa56d50e56c02000000000000": "0x6c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afca6eb22bebb0152101000000000000": "0x2101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321afe8a6056ab2a7ed5400000000000000": "0x5400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b019933bf758a2501901000000000000": "0x1901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b02434ada4ed83d4a500000000000000": "0xa500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b02de844403ec7ea0200000000000000": "0x0200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b03eda99cc2e3f307902000000000000": "0x7902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b0423c60a2c4bc78f900000000000000": "0xf900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b1606abfe4a728fc1400000000000000": "0x1400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b191643e464c8c81b402000000000000": "0xb402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b1c7ca82f48aa91ff002000000000000": "0xf002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b261c28f43e687c7c101000000000000": "0xc101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b269b92f5459bc573202000000000000": "0x3202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b27baec2ff0936169803000000000000": "0x9803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b29c2d17d5d0d0ffcf03000000000000": "0xcf03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b2d01d5604a94c366003000000000000": "0x6003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b33069cb5516fbeddc02000000000000": "0xdc02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b3395bed8316782b8c00000000000000": "0x8c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b3b18ee4bf8dc5637d03000000000000": "0x7d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b3ecb367a17f5408f001000000000000": "0xf001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b3f1f296a4bd40dc5000000000000000": "0x5000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b40d435058c1148cf600000000000000": "0xf600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b41ef3e411d15c920c02000000000000": "0x0c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b4531ae98e9c63c89401000000000000": "0x9401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b50f513ee1715a333001000000000000": "0x3001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b52b3440a19f9dea6a03000000000000": "0x6a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b5b1ca131bdfccc81302000000000000": "0x1302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b5ed311879a0d4844502000000000000": "0x4502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b5f894ed85218cda7c01000000000000": "0x7c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b6437bd9cd04b7376303000000000000": "0x6303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b654caccb0fec2e58c02000000000000": "0x8c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b6c8e0b7759b051c2602000000000000": "0x2602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b740b2c866fd4f014300000000000000": "0x4300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b7487e66d5c9ed6f5b00000000000000": "0x5b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b76fd1db4eb487c7a003000000000000": "0xa003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b8a60e8ff84c76ce4100000000000000": "0x4100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b8f253d2bea2761a9e02000000000000": "0x9e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b9140a2aea66ba0f3302000000000000": "0x3302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b966af519f6ef5333801000000000000": "0x3801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b986dc21e37c17a82803000000000000": "0x2803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b9c399fae7ee24480c01000000000000": "0x0c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321b9d090cc94fd2135d201000000000000": "0xd201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ba27eedc6b667ea6a601000000000000": "0xa601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ba39e32be0b1ded7a401000000000000": "0xa401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ba5afc976203fc1ae103000000000000": "0xe103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321babf49f52d726c265603000000000000": "0x5603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bacb31a77fc7b6ed7002000000000000": "0x7002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bb698cb9beea6a8ae500000000000000": "0xe500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bc13fd0998aeba1d8003000000000000": "0x8003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bc79ae2096fa980c0d03000000000000": "0x0d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bc8cd6ab8a1c93673203000000000000": "0x3203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bc8d6bb3dffb503a6302000000000000": "0x6302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bd34e8b2f1862b0ed703000000000000": "0xd703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bd35780f67318097eb00000000000000": "0xeb00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bd4f1ac45707c1f6e901000000000000": "0xe901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bdab5b8c9446dedfe902000000000000": "0xe902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bdcf39641a0061638a03000000000000": "0x8a03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321be1a11151ba77b3a1800000000000000": "0x1800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321be874ac539105bb3c803000000000000": "0xc803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321beab8d0d0758b987a900000000000000": "0xa900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321becf3b4388d2f343e000000000000000": "0xe000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bf139f57a073f0d87d01000000000000": "0x7d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bfa9de902c3172952000000000000000": "0x2000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bfd90444d0600d56ae02000000000000": "0xae02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321bff6ce998881877fa502000000000000": "0xa502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c011d838e7892cb42601000000000000": "0x2601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c05d379e76764fae0903000000000000": "0x0903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c05fbb9d607f82250503000000000000": "0x0503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c0610ff2b6bf4ccc6903000000000000": "0x6903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c082208925c45ac76901000000000000": "0x6901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c09e89491b7388259202000000000000": "0x9202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c0a8302bb2f1957f7f02000000000000": "0x7f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c0b93a7ad24ac995bf01000000000000": "0xbf01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c0f5658edcc164dc5001000000000000": "0x5001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c128bf1f4e0656aeaf00000000000000": "0xaf00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c15c6467486283f82d01000000000000": "0x2d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c17ae56a6b08e58a3b03000000000000": "0x3b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c1fc29468750ede8cb01000000000000": "0xcb01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c24373ed36eb2795b200000000000000": "0xb200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c2614e453d5ebefab502000000000000": "0xb502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c2dc369c03a6040d1b03000000000000": "0x1b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c2f971839039a7c84603000000000000": "0x4603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c35292ce0100355b7900000000000000": "0x7900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c368dd4c5ffbf002ae01000000000000": "0xae01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c3e8f5f69f6aa8fc5101000000000000": "0x5101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c40282ccb96d2d80ed01000000000000": "0xed01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c48564104a21ee97cd02000000000000": "0xcd02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c4e7d33822eec7f47702000000000000": "0x7702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c521f7c6e9c05c053002000000000000": "0x3002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c584a847d252be3c0f01000000000000": "0x0f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c5a5237644f655ebad03000000000000": "0xad03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c5bef715a0c05b622f01000000000000": "0x2f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c5c08420b23b5abc7701000000000000": "0x7701000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c5dba18fdb239d374203000000000000": "0x4203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c60f9e33658f0095b900000000000000": "0xb900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c657f09268fd11064c01000000000000": "0x4c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c670c2874f793a80cf02000000000000": "0xcf02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c69b92b9b02fdabdee02000000000000": "0xee02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c712386623c0e9dd2c00000000000000": "0x2c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c720ad615e2c0a50c000000000000000": "0xc000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c7323e46a5ecc29f0a02000000000000": "0x0a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c7f3b2b1237e1018d103000000000000": "0xd103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c888cc77bc24848ddd03000000000000": "0xdd03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c8a8897b2d198a22ca00000000000000": "0xca00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c8c22f08ec55ff0e1502000000000000": "0x1502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c8cec9e56627141c7003000000000000": "0x7003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c8f3b0cb45a89be81803000000000000": "0x1803000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c93e1640a0c05fd72f00000000000000": "0x2f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c94749b0685329c4c503000000000000": "0xc503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c94ecaf6afb5f7647500000000000000": "0x7500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c9548cf1960026def301000000000000": "0xf301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c998fc03229363307503000000000000": "0x7503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c9b28c24949011789603000000000000": "0x9603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321c9fc44d5943c6e750e03000000000000": "0x0e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ca1b4d3ae5eef018f402000000000000": "0xf402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ca2805f80fcd2e7b0602000000000000": "0x0602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cada3528e4c8a2792901000000000000": "0x2901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321caf9895a039ab0912f03000000000000": "0x2f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cafacd817f1bb76e4c03000000000000": "0x4c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cb5edec1155ae2a7d400000000000000": "0xd400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cb9871c4ee4bae2ed500000000000000": "0xd500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cb9aac8f91a14d765601000000000000": "0x5601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cc7c4370f2bab4d1d800000000000000": "0xd800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cc9d2e0bf31381a8f502000000000000": "0xf502000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cca254008d5f34222500000000000000": "0x2500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cca2e27c3d85a12c5c01000000000000": "0x5c01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ccc966cdc6962d4caa00000000000000": "0xaa00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cd6d75fea8769bb88700000000000000": "0x8700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cd74d88d640eb0299901000000000000": "0x9901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cdb1d2bdbe56958c7203000000000000": "0x7203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cdd54c170078c445af02000000000000": "0xaf02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cde0fd7bdd857447e200000000000000": "0xe200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ce2ae2c09cbadb23a201000000000000": "0xa201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ce5e70b0a9efbe824f01000000000000": "0x4f01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ce739d0c461a25eb3f02000000000000": "0x3f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ce951ca53cb361b88800000000000000": "0x8800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cf584a1d21b0f41d1e00000000000000": "0x1e00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cf7c67e6a09f4ab0ca02000000000000": "0xca02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cf7e9d35e86500839100000000000000": "0x9100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cf9445121193b4f73401000000000000": "0x3401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321cfb5015e5bef2b349400000000000000": "0x9400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d08398c0f1b9d38f3902000000000000": "0x3902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d0bb1de41f72ee82e202000000000000": "0xe202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d0c5d26dfa45659c3c00000000000000": "0x3c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d0c871fdf790c2f58d02000000000000": "0x8d02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d0e8d1824219296d7602000000000000": "0x7602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d11735527096e571ce03000000000000": "0xce03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d14f2b862c158b632202000000000000": "0x2202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d1dd202a20f729120003000000000000": "0x0003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d203080ad7af92fda901000000000000": "0xa901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d21147f69eecfaee9201000000000000": "0x9201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d215728fb45e20b3db02000000000000": "0xdb02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d283059f0dfcf3928303000000000000": "0x8303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d2947c06e7c67f0ce201000000000000": "0xe201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d2d31b9993c9f73f4801000000000000": "0x4801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d2eaf1804c215f7dbb00000000000000": "0xbb00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d319562e24bb5c536000000000000000": "0x6000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d374084ba340e7725e02000000000000": "0x5e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d467abcb7b32622b0302000000000000": "0x0302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d48d5f1fb366e87d0703000000000000": "0x0703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d53c7e37efd26f2e6402000000000000": "0x6402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d55618219369a9d81001000000000000": "0x1001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d5603149a2a3247d7000000000000000": "0x7000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d5fec0a75f0d9b386f00000000000000": "0x6f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d601ad28d8c9ac539a01000000000000": "0x9a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d6618eae740785614f03000000000000": "0x4f03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d668d2412a19d9b49700000000000000": "0x9700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d704c1f36d93183ea603000000000000": "0xa603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d718f6c14a8cc37bb000000000000000": "0xb000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d74e563fab59b3080e02000000000000": "0x0e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d75361fdb5a730586d03000000000000": "0x6d03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d75edb5fec9717034601000000000000": "0x4601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d7681490212a36870a01000000000000": "0x0a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d784bc93bc8b41345301000000000000": "0x5301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d7e259a1ccb49a64cc01000000000000": "0xcc01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d85f26ac231f8b5dfb01000000000000": "0xfb01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d888b50e4d5978547b03000000000000": "0x7b03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d8bf402699f5b4a8e303000000000000": "0xe303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d8e73918bde17578d700000000000000": "0xd700000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321d9e0eeb6b3b2f470ef01000000000000": "0xef01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321da2bda9e9a1b0b8ddf03000000000000": "0xdf03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321da70c51cf14f90b46e01000000000000": "0x6e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321da9ff003c18eada4d903000000000000": "0xd903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321db307c23c086e05ab002000000000000": "0xb002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dba812c4c5e1500f8801000000000000": "0x8801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dc12eda68ca517e72102000000000000": "0x2102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dc8b5e1b7d061a88ca03000000000000": "0xca03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dcb8a4a072e595a0bc03000000000000": "0xbc03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dcdc98234811767bc302000000000000": "0xc302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dcdedf9c1010c6614001000000000000": "0x4001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dd4fa08c178fa8d9d901000000000000": "0xd901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dd62a4d5f4172290a801000000000000": "0xa801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dd6cc1900d3f04d14103000000000000": "0x4103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dd7c7130dc08d4c90301000000000000": "0x0301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dda154ccd342115e1602000000000000": "0x1602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ddb3aab8cff721928e02000000000000": "0x8e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321de4533e88951eb7b8100000000000000": "0x8100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321de5b91e5fbef5d93ec01000000000000": "0xec01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321deee352f1087d3027801000000000000": "0x7801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321defdc3f60837ca323000000000000000": "0x3000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321df01298300dfdc4f8d00000000000000": "0x8d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321df15689db8d6f1bd8b01000000000000": "0x8b01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dfb70447812c50687200000000000000": "0x7200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dfc448edff971a100401000000000000": "0x0401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321dfea96dca0d4537f0b00000000000000": "0x0b00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e00bb3fc5efbc036c900000000000000": "0xc900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e0404c62fd1f2145e702000000000000": "0xe702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e053adb8c08052770202000000000000": "0x0202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e08b861b3d7382234102000000000000": "0x4102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e0c0c90749c3e7b43b02000000000000": "0x3b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e0e07c6bec0990e4be01000000000000": "0xbe01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e1212d2ff4a55748d202000000000000": "0xd202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e15dcecee8f603143303000000000000": "0x3303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e180d490b0d7068b5600000000000000": "0x5600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e191e352beebc7ea8603000000000000": "0x8603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e196b58844455f266e03000000000000": "0x6e03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e1cbfb770b4db02d5003000000000000": "0x5003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e1d21277d38fc3ba1c03000000000000": "0x1c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e27ceb44fb15d4a76a01000000000000": "0x6a01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e2bd457ba6c64d54c601000000000000": "0xc601000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e2c0a2a258da3805a600000000000000": "0xa600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e2fce2b1123a53567600000000000000": "0x7600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e31b95415fbdbeaf6300000000000000": "0x6300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e33ef4fcbed9d404bd00000000000000": "0xbd00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e38011acf85b25fbf501000000000000": "0xf501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e398b9a27555d4d7aa02000000000000": "0xaa02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e3bb7f8567b0bead7a02000000000000": "0x7a02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e3e2af5f6df62dd09b02000000000000": "0x9b02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e416f4dc5cc4c9d44201000000000000": "0x4201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e5d9d06d1ea28a529002000000000000": "0x9002000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e607cf5bb9eb13afdc01000000000000": "0xdc01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e6a159928d4b4ec3b800000000000000": "0xb800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e76f732a14c24616b503000000000000": "0xb503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e7e15897f90f8fa59801000000000000": "0x9801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e7ffe8566031eae73c02000000000000": "0x3c02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e848a851e9c6139e9503000000000000": "0x9503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e87dcb4f1c893e5c6900000000000000": "0x6900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e8c3f017a056bc910f00000000000000": "0x0f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e93088202793fbca7401000000000000": "0x7401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e9428ad66ec9de649101000000000000": "0x9101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e99ec85932be5b966100000000000000": "0x6100000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321e9f331ed4e344139e403000000000000": "0xe403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ea02a1af8b118fb06102000000000000": "0x6102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ea56775d670a078b2902000000000000": "0x2902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ea67efa3a2a197674f02000000000000": "0x4f02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ead5c5d27602e1997703000000000000": "0x7703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eadd9320b4e415860e01000000000000": "0x0e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eaea1f27dc45ee99d503000000000000": "0xd503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eb00435b4c22caa29903000000000000": "0x9903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eb3c81f73470cd586600000000000000": "0x6600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eb5f6f4ae4efadc93d00000000000000": "0x3d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eb688e29eba3199db600000000000000": "0xb600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ec021c07b719ce697e01000000000000": "0x7e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ec191cb8cc4d9e11db03000000000000": "0xdb03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eccc2f2c8dd2d5ba8400000000000000": "0x8400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ecdc81400120b4750102000000000000": "0x0102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ece17b4d9132af41ee00000000000000": "0xee00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ed5ac52a6d9c37955702000000000000": "0x5702000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ed78641c153d9a1e1a00000000000000": "0x1a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ed7d7d0843c95e959703000000000000": "0x9703000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ed8347073814ff11fe02000000000000": "0xfe02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eda75273be5d877b9403000000000000": "0x9403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eea5e1a468c6e6627603000000000000": "0x7603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eed40c97f629adf32801000000000000": "0x2801000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321eff6afbf32a48fdf1e02000000000000": "0x1e02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f146bf628fea5dba8001000000000000": "0x8001000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f14f143f6fea8eae5e01000000000000": "0x5e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f15f87d893f4fae7cd03000000000000": "0xcd03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f1e694844da4d49a8e01000000000000": "0x8e01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f2b752f43231cc821202000000000000": "0x1202000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f2cd9a1dd8a547482c03000000000000": "0x2c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f353f7374e732ead9c00000000000000": "0x9c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f3ff6597c9a6253dce02000000000000": "0xce02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f42826367c808e1c2903000000000000": "0x2903000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f45193c2634429c5f902000000000000": "0xf902000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f477d66ddba32cf6bf02000000000000": "0xbf02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f489994691e69d763901000000000000": "0x3901000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f510adae845b0e13d101000000000000": "0xd101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f52b82b5e30eba277a00000000000000": "0x7a00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f567943c1e6f8c788201000000000000": "0x8201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f58adf1bfc7b0b59e300000000000000": "0xe300000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f5cdb3589da164e66200000000000000": "0x6200000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f5d15cf10f2566b44f00000000000000": "0x4f00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f600f0f35dbc0f68db00000000000000": "0xdb00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f728885644fe36f89900000000000000": "0x9900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f7bd1583e9a173ce9500000000000000": "0x9500000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f8039a8d5352807bc103000000000000": "0xc103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f82a45a5cd194ea22302000000000000": "0x2302000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f82ef8c0415812004400000000000000": "0x4400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f8f4e117cc61ef6c8401000000000000": "0x8401000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f92987139063565f3301000000000000": "0x3301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f9381bd21c174a701d00000000000000": "0x1d00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f93cd8f8c8882ab56501000000000000": "0x6501000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f94eaa8b35b7276a0d01000000000000": "0x0d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f9c93a8474325e6e7103000000000000": "0x7103000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321f9f93a24c5b38297c301000000000000": "0xc301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fa12994430ad6d0db403000000000000": "0xb403000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fa48a1dc4a8bc718f602000000000000": "0xf602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fa6fd76e3588a74dde01000000000000": "0xde01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fb0e17fb52f37b65cc02000000000000": "0xcc02000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fb3a8211b5c332951603000000000000": "0x1603000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fb6f484b36a70388f101000000000000": "0xf101000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fb8f3e7cdf66ae598c03000000000000": "0x8c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fca206814d26bffc1301000000000000": "0x1301000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fcbfbbdb910032c0a203000000000000": "0xa203000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fcdcebe9db90331e9c03000000000000": "0x9c03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fce2ca7ad3e1fbee3400000000000000": "0x3400000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fcf31ac4d85d61bb7c00000000000000": "0x7c00000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fd1a4b8e952475b75900000000000000": "0x5900000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fd228552f5305f261402000000000000": "0x1402000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fd36076f8dc022354003000000000000": "0x4003000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fd54662142ba1a765800000000000000": "0x5800000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fd59d0ec3d0a81593201000000000000": "0x3201000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fdafe3f18724a4265d01000000000000": "0x5d01000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fde43b928ff5cafcf102000000000000": "0xf102000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fe7482f9ab46f6fab602000000000000": "0xb602000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321feadd3a5082978874503000000000000": "0x4503000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ff660b590b6d0850c600000000000000": "0xc600000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321ffc674f174677bd49303000000000000": "0x9303000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a026aeec20cade12bc75fdc260fa2f3321fff494a9f86631e3bd03000000000000": "0xbd03000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f4500000000000000000000000000a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45000000", - "0xdc90e6f82b1c3812e102a180b502f8a04e7b9012096b41c4eb3aaf947f6ea429": "0x0000", - "0xf0c365c3cf59d671eb72da0e7a4113c44e7b9012096b41c4eb3aaf947f6ea429": "0x0000" - }, - "childrenDefault": {} - } - } -} \ No newline at end of file diff --git a/node/rpc/Cargo.toml b/node/rpc/Cargo.toml new file mode 100644 index 0000000..9b05a1e --- /dev/null +++ b/node/rpc/Cargo.toml @@ -0,0 +1,40 @@ +[package] +name = "node-rpc" +version = "3.0.0-dev" +authors = ["Parity Technologies "] +description = "Substrate node rpc methods." +edition = "2021" +license = "Apache-2.0" +homepage = "https://substrate.io" +repository = "https://github.com/paritytech/substrate/" +publish = false + +[package.metadata.docs.rs] +targets = ["x86_64-unknown-linux-gnu"] + +[dependencies] +jsonrpsee = { version = "0.16.2", features = ["server"] } +node-primitives = { version = "2.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-transaction-payment-rpc = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +mmr-rpc = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-chain-spec = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-client-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus-babe = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus-babe-rpc = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-consensus-epochs = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-finality-grandpa = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-finality-grandpa-rpc = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-rpc = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-rpc-api = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-rpc-spec-v2 = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-sync-state-rpc = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sc-transaction-pool-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-api = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-block-builder = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-blockchain = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-consensus = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-consensus-babe = { version = "0.10.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-keystore = { version = "0.13.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +sp-runtime = { version = "7.0.0", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +substrate-frame-rpc-system = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +substrate-state-trie-migration-rpc = { version = "4.0.0-dev", git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } diff --git a/node/rpc/src/lib.rs b/node/rpc/src/lib.rs new file mode 100644 index 0000000..87b4cf4 --- /dev/null +++ b/node/rpc/src/lib.rs @@ -0,0 +1,184 @@ +// This file is part of Substrate. + +// Copyright (C) 2019-2022 Parity Technologies (UK) Ltd. +// SPDX-License-Identifier: Apache-2.0 + +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +//! A collection of node-specific RPC methods. +//! +//! Since `substrate` core functionality makes no assumptions +//! about the modules used inside the runtime, so do +//! RPC methods defined in `sc-rpc` crate. +//! It means that `client/rpc` can't have any methods that +//! need some strong assumptions about the particular runtime. +//! +//! The RPCs available in this crate however can make some assumptions +//! about how the runtime is constructed and what FRAME pallets +//! are part of it. Therefore all node-runtime-specific RPCs can +//! be placed here or imported from corresponding FRAME RPC definitions. + +#![warn(missing_docs)] +#![warn(unused_crate_dependencies)] + +use std::sync::Arc; + +use jsonrpsee::RpcModule; +use node_primitives::{AccountId, Balance, Block, BlockNumber, Hash, Index}; +use sc_client_api::AuxStore; +use sc_consensus_babe::{BabeConfiguration, Epoch}; +use sc_consensus_epochs::SharedEpochChanges; +use sc_finality_grandpa::{ + FinalityProofProvider, GrandpaJustificationStream, SharedAuthoritySet, SharedVoterState, +}; +use sc_rpc::SubscriptionTaskExecutor; +pub use sc_rpc_api::DenyUnsafe; +use sc_transaction_pool_api::TransactionPool; +use sp_api::ProvideRuntimeApi; +use sp_block_builder::BlockBuilder; +use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata}; +use sp_consensus::SelectChain; +use sp_consensus_babe::BabeApi; +use sp_keystore::SyncCryptoStorePtr; + +/// Extra dependencies for BABE. +pub struct BabeDeps { + /// BABE protocol config. + pub babe_config: BabeConfiguration, + /// BABE pending epoch changes. + pub shared_epoch_changes: SharedEpochChanges, + /// The keystore that manages the keys of the node. + pub keystore: SyncCryptoStorePtr, +} + +/// Extra dependencies for GRANDPA +pub struct GrandpaDeps { + /// Voting round info. + pub shared_voter_state: SharedVoterState, + /// Authority set info. + pub shared_authority_set: SharedAuthoritySet, + /// Receives notifications about justification events from Grandpa. + pub justification_stream: GrandpaJustificationStream, + /// Executor to drive the subscription manager in the Grandpa RPC handler. + pub subscription_executor: SubscriptionTaskExecutor, + /// Finality proof provider. + pub finality_provider: Arc>, +} + +/// Full client dependencies. +pub struct FullDeps { + /// The client instance to use. + pub client: Arc, + /// Transaction pool instance. + pub pool: Arc

, + /// The SelectChain Strategy + pub select_chain: SC, + /// A copy of the chain spec. + pub chain_spec: Box, + /// Whether to deny unsafe calls + pub deny_unsafe: DenyUnsafe, + /// BABE specific dependencies. + pub babe: BabeDeps, + /// GRANDPA specific dependencies. + pub grandpa: GrandpaDeps, +} + +/// Instantiate all Full RPC extensions. +pub fn create_full( + deps: FullDeps, + backend: Arc, +) -> Result, Box> +where + C: ProvideRuntimeApi + + sc_client_api::BlockBackend + + HeaderBackend + + AuxStore + + HeaderMetadata + + Sync + + Send + + 'static, + C::Api: substrate_frame_rpc_system::AccountNonceApi, + // C::Api: mmr_rpc::MmrRuntimeApi::Hash, BlockNumber>, + C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi, + C::Api: BabeApi, + C::Api: BlockBuilder, + P: TransactionPool + 'static, + SC: SelectChain + 'static, + B: sc_client_api::Backend + Send + Sync + 'static, + B::State: sc_client_api::backend::StateBackend>, +{ + // use mmr_rpc::{Mmr, MmrApiServer}; + use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer}; + use sc_consensus_babe_rpc::{Babe, BabeApiServer}; + use sc_finality_grandpa_rpc::{Grandpa, GrandpaApiServer}; + use sc_rpc::dev::{Dev, DevApiServer}; + use sc_rpc_spec_v2::chain_spec::{ChainSpec, ChainSpecApiServer}; + use sc_sync_state_rpc::{SyncState, SyncStateApiServer}; + use substrate_frame_rpc_system::{System, SystemApiServer}; + use substrate_state_trie_migration_rpc::{StateMigration, StateMigrationApiServer}; + + let mut io = RpcModule::new(()); + let FullDeps { client, pool, select_chain, chain_spec, deny_unsafe, babe, grandpa } = deps; + + let BabeDeps { keystore, babe_config, shared_epoch_changes } = babe; + let GrandpaDeps { + shared_voter_state, + shared_authority_set, + justification_stream, + subscription_executor, + finality_provider, + } = grandpa; + + let chain_name = chain_spec.name().to_string(); + let genesis_hash = client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"); + let properties = chain_spec.properties(); + io.merge(ChainSpec::new(chain_name, genesis_hash, properties).into_rpc())?; + + io.merge(System::new(client.clone(), pool, deny_unsafe).into_rpc())?; + // Making synchronous calls in light client freezes the browser currently, + // more context: https://github.com/paritytech/substrate/pull/3480 + // These RPCs should use an asynchronous caller instead. + // io.merge(Mmr::new(client.clone()).into_rpc())?; + io.merge(TransactionPayment::new(client.clone()).into_rpc())?; + io.merge( + Babe::new( + client.clone(), + shared_epoch_changes.clone(), + keystore, + babe_config, + select_chain, + deny_unsafe, + ) + .into_rpc(), + )?; + io.merge( + Grandpa::new( + subscription_executor, + shared_authority_set.clone(), + shared_voter_state, + justification_stream, + finality_provider, + ) + .into_rpc(), + )?; + + io.merge( + SyncState::new(chain_spec, client.clone(), shared_authority_set, shared_epoch_changes)? + .into_rpc(), + )?; + + io.merge(StateMigration::new(client.clone(), backend, deny_unsafe).into_rpc())?; + io.merge(Dev::new(client, deny_unsafe).into_rpc())?; + + Ok(io) +} diff --git a/node/src/chain_spec.rs b/node/src/chain_spec.rs deleted file mode 100644 index ce0bafe..0000000 --- a/node/src/chain_spec.rs +++ /dev/null @@ -1,225 +0,0 @@ -use xsocial_runtime::{AccountId, BalancesConfig, CollatorSelectionConfig, EXISTENTIAL_DEPOSIT, GenesisConfig, GrandpaConfig, Signature, SudoConfig, SystemConfig, UNIT, WASM_BINARY}; -use sc_service::ChainType; -use sc_chain_spec::Properties; -use sc_telemetry::TelemetryEndpoints; -use sp_consensus_babe::AuthorityId as BabeId; -use sp_core::{sr25519, Pair, Public}; -use sp_finality_grandpa::AuthorityId as GrandpaId; -use sp_runtime::traits::{IdentifyAccount, Verify}; -use hex_literal::hex; - -// The URL for the telemetry server. -const STAGING_TELEMETRY_URL: &str = "wss://telemetry.polkadot.io/submit/"; -const DEFAULT_PROTOCOL_ID: &str = "sub-xsocial-v0"; - -/// Specialized `ChainSpec`. This is a specialization of the general Substrate ChainSpec type. -pub type ChainSpec = sc_service::GenericChainSpec; - -/// Generate a crypto pair from seed. -pub fn get_from_seed(seed: &str) -> ::Public { - TPublic::Pair::from_string(&format!("//{}", seed), None) - .expect("static values are valid; qed") - .public() -} - -type AccountPublic = ::Signer; - -/// Generate an account ID from seed. -pub fn get_account_id_from_seed(seed: &str) -> AccountId -where - AccountPublic: From<::Public>, -{ - AccountPublic::from(get_from_seed::(seed)).into_account() -} - -/// Generate an Babe authority key. -pub fn authority_keys_from_seed(s: &str) -> (AccountId, BabeId, GrandpaId) { - (get_account_id_from_seed::(s), get_from_seed::(s), get_from_seed::(s)) -} - -pub fn development_config() -> Result { - let wasm_binary = WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?; - - Ok(ChainSpec::from_genesis( - // Name - "Development", - // ID - "dev", - ChainType::Development, - move || { - testnet_genesis( - wasm_binary, - // Initial PoA authorities - vec![authority_keys_from_seed("Alice")], - // Sudo account - get_account_id_from_seed::("Alice"), - // Pre-funded accounts - vec![ - get_account_id_from_seed::("Alice"), - get_account_id_from_seed::("Bob"), - get_account_id_from_seed::("Alice//stash"), - get_account_id_from_seed::("Bob//stash"), - ], - true, - ) - }, - // Bootnodes - vec![], - // Telemetry - None, - // Protocol ID - None, - None, - // Properties - Some(subsocial_properties()), - // Extensions - None, - )) -} - -pub fn local_testnet_config() -> Result { - let wasm_binary = WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?; - - Ok(ChainSpec::from_genesis( - // Name - "Local Testnet", - // ID - "local_testnet", - ChainType::Local, - move || { - testnet_genesis( - wasm_binary, - // Initial PoA authorities - vec![authority_keys_from_seed("Alice"), authority_keys_from_seed("Bob")], - // Sudo account - get_account_id_from_seed::("Alice"), - // Pre-funded accounts - vec![ - get_account_id_from_seed::("Alice"), - get_account_id_from_seed::("Bob"), - get_account_id_from_seed::("Charlie"), - get_account_id_from_seed::("Dave"), - get_account_id_from_seed::("Eve"), - get_account_id_from_seed::("Ferdie"), - get_account_id_from_seed::("Alice//stash"), - get_account_id_from_seed::("Bob//stash"), - get_account_id_from_seed::("Charlie//stash"), - get_account_id_from_seed::("Dave//stash"), - get_account_id_from_seed::("Eve//stash"), - get_account_id_from_seed::("Ferdie//stash"), - ], - true, - ) - }, - // Bootnodes - vec![], - // Telemetry - None, - // Protocol ID - None, - // Properties - None, - None, - // Extensions - None, - )) -} - -pub fn xsocial_testnet_config() -> Result { - ChainSpec::from_json_bytes(&include_bytes!("../res/xsocial.json")[..]) -} - -pub fn staging_testnet_config() -> Result { - let wasm_binary = WASM_BINARY.ok_or_else(|| "Development wasm not available".to_string())?; - - Ok(ChainSpec::from_genesis( - // Name - "XSocial Testnet", - // ID - "xsocial_testnet", - ChainType::Live, - move || { - let root_key: AccountId = hex!["a8d5b1558ee63ed2c55c8fb71afd2cbe7a2f61c0fc2dbab741ca652ecf6a3f45"].into(); - let initial_authorities: Vec<(BabeId, GrandpaId)> = vec![ - // TODO: fix - // ( - // hex!["d4f4482d82913b5a4ef195bba7ec5567ee04b6ea784139c04ee5e77530670149"].unchecked_into(), - // hex!["419c48625508cc74c8c125dd0132158d3583b479975e516c3c2cc1457d11a7c5"].unchecked_into(), - // ), - // ( - // hex!["640f97526d653b620d1ccbdefa4cb212cc0dfc76f77a0f631f96f009d986464b"].unchecked_into(), - // hex!["b553650f5032ecadba5df3bd35e8d280bc6f5cdff1beda8c504d6cfecc89c63a"].unchecked_into(), - // ), - ]; - testnet_genesis( - wasm_binary, - // Initial PoA authorities - Default::default(), - // Sudo account - root_key.clone(), - // Pre-funded accounts - vec![root_key.clone()], - true, - ) - }, - // Bootnodes - vec![], - // Telemetry - TelemetryEndpoints::new(vec![(STAGING_TELEMETRY_URL.to_string(), 0)]).ok(), - // Protocol ID - Some(DEFAULT_PROTOCOL_ID), - // Properties - None, - Some(subsocial_properties()), - // Extensions - None, - )) -} - -/// Configure initial storage state for FRAME modules. -fn testnet_genesis( - wasm_binary: &[u8], - invulnerables: Vec<(AccountId, BabeId, GrandpaId)>, - root_key: AccountId, - endowed_accounts: Vec, - _enable_println: bool, -) -> GenesisConfig { - GenesisConfig { - system: SystemConfig { - // Add Wasm runtime to storage. - code: wasm_binary.to_vec(), - }, - collator_selection: CollatorSelectionConfig { - invulnerables: invulnerables.iter().cloned().map(|(acc, _, _)| acc).collect(), - candidacy_bond: EXISTENTIAL_DEPOSIT * 16, - ..Default::default() - }, - session: Default::default(), - balances: BalancesConfig { - // Configure endowed accounts with initial balance of 1 << 60. - balances: endowed_accounts.iter().cloned().map(|k| (k, 1_000_000 * UNIT)).collect(), - }, - grandpa: GrandpaConfig { - authorities: invulnerables.iter().map(|x| (x.2.clone(), 1)).collect(), - }, - sudo: SudoConfig { - // Assign network admin rights. - key: Some(root_key.clone()), - }, - transaction_payment: Default::default(), - spaces: xsocial_runtime::SpacesConfig { - endowed_account: Some(root_key), - }, - babe: Default::default(), - } -} - -pub fn subsocial_properties() -> Properties { - let mut properties = Properties::new(); - - properties.insert("ss58Format".into(), 28.into()); - properties.insert("tokenDecimals".into(), 10.into()); - properties.insert("tokenSymbol".into(), "SUB".into()); - - properties -} diff --git a/node/src/cli.rs b/node/src/cli.rs deleted file mode 100644 index dd61047..0000000 --- a/node/src/cli.rs +++ /dev/null @@ -1,53 +0,0 @@ -use sc_cli::RunCmd; - -#[derive(Debug, clap::Parser)] -pub struct Cli { - #[command(subcommand)] - pub subcommand: Option, - - #[clap(flatten)] - pub run: RunCmd, -} - -#[derive(Debug, clap::Subcommand)] -pub enum Subcommand { - /// Key management cli utilities - #[command(subcommand)] - Key(sc_cli::KeySubcommand), - - /// Build a chain specification. - BuildSpec(sc_cli::BuildSpecCmd), - - /// Validate blocks. - CheckBlock(sc_cli::CheckBlockCmd), - - /// Export blocks. - ExportBlocks(sc_cli::ExportBlocksCmd), - - /// Export the state of a given block into a chain spec. - ExportState(sc_cli::ExportStateCmd), - - /// Import blocks. - ImportBlocks(sc_cli::ImportBlocksCmd), - - /// Remove the whole chain. - PurgeChain(sc_cli::PurgeChainCmd), - - /// Revert the chain to a previous state. - Revert(sc_cli::RevertCmd), - - /// Sub-commands concerned with benchmarking. - #[command(subcommand)] - Benchmark(frame_benchmarking_cli::BenchmarkCmd), - - /// Try some command against runtime state. - #[cfg(feature = "try-runtime")] - TryRuntime(try_runtime_cli::TryRuntimeCmd), - - /// Try some command against runtime state. Note: `try-runtime` feature must be enabled. - #[cfg(not(feature = "try-runtime"))] - TryRuntime, - - /// Db meta columns information. - ChainInfo(sc_cli::ChainInfoCmd), -} diff --git a/node/src/lib.rs b/node/src/lib.rs deleted file mode 100644 index f117b8a..0000000 --- a/node/src/lib.rs +++ /dev/null @@ -1,3 +0,0 @@ -pub mod chain_spec; -pub mod rpc; -pub mod service; diff --git a/node/src/main.rs b/node/src/main.rs deleted file mode 100644 index 2d5052b..0000000 --- a/node/src/main.rs +++ /dev/null @@ -1,14 +0,0 @@ -//! Substrate Node CLI library. -#![warn(missing_docs)] - -mod chain_spec; -#[macro_use] -mod service; -mod benchmarking; -mod cli; -mod command; -mod rpc; - -fn main() -> sc_cli::Result<()> { - command::run() -} diff --git a/node/src/rpc.rs b/node/src/rpc.rs deleted file mode 100644 index c0ebe6d..0000000 --- a/node/src/rpc.rs +++ /dev/null @@ -1,57 +0,0 @@ -//! A collection of node-specific RPC methods. -//! Substrate provides the `sc-rpc` crate, which defines the core RPC layer -//! used by Substrate nodes. This file extends those RPC definitions with -//! capabilities that are specific to this project's runtime configuration. - -#![warn(missing_docs)] - -use std::sync::Arc; - -use jsonrpsee::RpcModule; -use xsocial_runtime::{opaque::Block, AccountId, Balance, Index}; -use sc_transaction_pool_api::TransactionPool; -use sp_api::ProvideRuntimeApi; -use sp_block_builder::BlockBuilder; -use sp_blockchain::{Error as BlockChainError, HeaderBackend, HeaderMetadata}; - -pub use sc_rpc_api::DenyUnsafe; - -/// Full client dependencies. -pub struct FullDeps { - /// The client instance to use. - pub client: Arc, - /// Transaction pool instance. - pub pool: Arc

, - /// Whether to deny unsafe calls - pub deny_unsafe: DenyUnsafe, -} - -/// Instantiate all full RPC extensions. -pub fn create_full( - deps: FullDeps, -) -> Result, Box> -where - C: ProvideRuntimeApi, - C: HeaderBackend + HeaderMetadata + 'static, - C: Send + Sync + 'static, - C::Api: substrate_frame_rpc_system::AccountNonceApi, - C::Api: pallet_transaction_payment_rpc::TransactionPaymentRuntimeApi, - C::Api: BlockBuilder, - P: TransactionPool + 'static, -{ - use pallet_transaction_payment_rpc::{TransactionPayment, TransactionPaymentApiServer}; - use substrate_frame_rpc_system::{System, SystemApiServer}; - - let mut module = RpcModule::new(()); - let FullDeps { client, pool, deny_unsafe } = deps; - - module.merge(System::new(client.clone(), pool.clone(), deny_unsafe).into_rpc())?; - module.merge(TransactionPayment::new(client).into_rpc())?; - - // Extend this RPC with a custom API by using the following syntax. - // `YourRpcStruct` should have a reference to a client, which is needed - // to call into the runtime. - // `module.merge(YourRpcTrait::into_rpc(YourRpcStruct::new(ReferenceToClient, ...)))?;` - - Ok(module) -} diff --git a/node/src/service.rs b/node/src/service.rs deleted file mode 100644 index 258d396..0000000 --- a/node/src/service.rs +++ /dev/null @@ -1,340 +0,0 @@ -//! Service and ServiceFactory implementation. Specialized wrapper over substrate service. - -use xsocial_runtime::{self, opaque::Block, RuntimeApi}; -use sc_client_api::BlockBackend; -use sc_consensus_aura::{ImportQueueParams, SlotProportion, StartAuraParams}; -pub use sc_executor::NativeElseWasmExecutor; -use sc_finality_grandpa::SharedVoterState; -use sc_keystore::LocalKeystore; -use sc_service::{error::Error as ServiceError, Configuration, TaskManager}; -use sc_telemetry::{Telemetry, TelemetryWorker}; -use sp_consensus_aura::sr25519::AuthorityPair as AuraPair; -use std::{sync::Arc, time::Duration}; - -// Our native executor instance. -pub struct ExecutorDispatch; - -impl sc_executor::NativeExecutionDispatch for ExecutorDispatch { - /// Only enable the benchmarking host functions when we actually want to benchmark. - #[cfg(feature = "runtime-benchmarks")] - type ExtendHostFunctions = frame_benchmarking::benchmarking::HostFunctions; - /// Otherwise we only use the default Substrate host functions. - #[cfg(not(feature = "runtime-benchmarks"))] - type ExtendHostFunctions = (); - - fn dispatch(method: &str, data: &[u8]) -> Option> { - xsocial_runtime::api::dispatch(method, data) - } - - fn native_version() -> sc_executor::NativeVersion { - xsocial_runtime::native_version() - } -} - -pub(crate) type FullClient = - sc_service::TFullClient>; -type FullBackend = sc_service::TFullBackend; -type FullSelectChain = sc_consensus::LongestChain; - -pub fn new_partial( - config: &Configuration, -) -> Result< - sc_service::PartialComponents< - FullClient, - FullBackend, - FullSelectChain, - sc_consensus::DefaultImportQueue, - sc_transaction_pool::FullPool, - ( - sc_finality_grandpa::GrandpaBlockImport< - FullBackend, - Block, - FullClient, - FullSelectChain, - >, - sc_finality_grandpa::LinkHalf, - Option, - ), - >, - ServiceError, -> { - if config.keystore_remote.is_some() { - return Err(ServiceError::Other("Remote Keystores are not supported.".into())) - } - - let telemetry = config - .telemetry_endpoints - .clone() - .filter(|x| !x.is_empty()) - .map(|endpoints| -> Result<_, sc_telemetry::Error> { - let worker = TelemetryWorker::new(16)?; - let telemetry = worker.handle().new_telemetry(endpoints); - Ok((worker, telemetry)) - }) - .transpose()?; - - let executor = NativeElseWasmExecutor::::new( - config.wasm_method, - config.default_heap_pages, - config.max_runtime_instances, - config.runtime_cache_size, - ); - - let (client, backend, keystore_container, task_manager) = - sc_service::new_full_parts::( - config, - telemetry.as_ref().map(|(_, telemetry)| telemetry.handle()), - executor, - )?; - let client = Arc::new(client); - - let telemetry = telemetry.map(|(worker, telemetry)| { - task_manager.spawn_handle().spawn("telemetry", None, worker.run()); - telemetry - }); - - let select_chain = sc_consensus::LongestChain::new(backend.clone()); - - let transaction_pool = sc_transaction_pool::BasicPool::new_full( - config.transaction_pool.clone(), - config.role.is_authority().into(), - config.prometheus_registry(), - task_manager.spawn_essential_handle(), - client.clone(), - ); - - let (grandpa_block_import, grandpa_link) = sc_finality_grandpa::block_import( - client.clone(), - &(client.clone() as Arc<_>), - select_chain.clone(), - telemetry.as_ref().map(|x| x.handle()), - )?; - - let slot_duration = sc_consensus_aura::slot_duration(&*client)?; - - let import_queue = - sc_consensus_aura::import_queue::(ImportQueueParams { - block_import: grandpa_block_import.clone(), - justification_import: Some(Box::new(grandpa_block_import.clone())), - client: client.clone(), - create_inherent_data_providers: move |_, ()| async move { - let timestamp = sp_timestamp::InherentDataProvider::from_system_time(); - - let slot = - sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration( - *timestamp, - slot_duration, - ); - - Ok((slot, timestamp)) - }, - spawner: &task_manager.spawn_essential_handle(), - registry: config.prometheus_registry(), - check_for_equivocation: Default::default(), - telemetry: telemetry.as_ref().map(|x| x.handle()), - compatibility_mode: Default::default(), - })?; - - Ok(sc_service::PartialComponents { - client, - backend, - task_manager, - import_queue, - keystore_container, - select_chain, - transaction_pool, - other: (grandpa_block_import, grandpa_link, telemetry), - }) -} - -fn remote_keystore(_url: &String) -> Result, &'static str> { - // FIXME: here would the concrete keystore be built, - // must return a concrete type (NOT `LocalKeystore`) that - // implements `CryptoStore` and `SyncCryptoStore` - Err("Remote Keystore not supported.") -} - -/// Builds a new service for a full client. -pub fn new_full(mut config: Configuration) -> Result { - let sc_service::PartialComponents { - client, - backend, - mut task_manager, - import_queue, - mut keystore_container, - select_chain, - transaction_pool, - other: (block_import, grandpa_link, mut telemetry), - } = new_partial(&config)?; - - if let Some(url) = &config.keystore_remote { - match remote_keystore(url) { - Ok(k) => keystore_container.set_remote_keystore(k), - Err(e) => - return Err(ServiceError::Other(format!( - "Error hooking up remote keystore for {}: {}", - url, e - ))), - }; - } - let grandpa_protocol_name = sc_finality_grandpa::protocol_standard_name( - &client.block_hash(0).ok().flatten().expect("Genesis block exists; qed"), - &config.chain_spec, - ); - - config - .network - .extra_sets - .push(sc_finality_grandpa::grandpa_peers_set_config(grandpa_protocol_name.clone())); - let warp_sync = Arc::new(sc_finality_grandpa::warp_proof::NetworkProvider::new( - backend.clone(), - grandpa_link.shared_authority_set().clone(), - Vec::default(), - )); - - let (network, system_rpc_tx, tx_handler_controller, network_starter) = - sc_service::build_network(sc_service::BuildNetworkParams { - config: &config, - client: client.clone(), - transaction_pool: transaction_pool.clone(), - spawn_handle: task_manager.spawn_handle(), - import_queue, - block_announce_validator_builder: None, - warp_sync: Some(warp_sync), - })?; - - if config.offchain_worker.enabled { - sc_service::build_offchain_workers( - &config, - task_manager.spawn_handle(), - client.clone(), - network.clone(), - ); - } - - let role = config.role.clone(); - let force_authoring = config.force_authoring; - let backoff_authoring_blocks: Option<()> = None; - let name = config.network.node_name.clone(); - let enable_grandpa = !config.disable_grandpa; - let prometheus_registry = config.prometheus_registry().cloned(); - - let rpc_extensions_builder = { - let client = client.clone(); - let pool = transaction_pool.clone(); - - Box::new(move |deny_unsafe, _| { - let deps = - crate::rpc::FullDeps { client: client.clone(), pool: pool.clone(), deny_unsafe }; - crate::rpc::create_full(deps).map_err(Into::into) - }) - }; - - let _rpc_handlers = sc_service::spawn_tasks(sc_service::SpawnTasksParams { - network: network.clone(), - client: client.clone(), - keystore: keystore_container.sync_keystore(), - task_manager: &mut task_manager, - transaction_pool: transaction_pool.clone(), - rpc_builder: rpc_extensions_builder, - backend, - system_rpc_tx, - tx_handler_controller, - config, - telemetry: telemetry.as_mut(), - })?; - - if role.is_authority() { - let proposer_factory = sc_basic_authorship::ProposerFactory::new( - task_manager.spawn_handle(), - client.clone(), - transaction_pool, - prometheus_registry.as_ref(), - telemetry.as_ref().map(|x| x.handle()), - ); - - let slot_duration = sc_consensus_aura::slot_duration(&*client)?; - - let aura = sc_consensus_aura::start_aura::( - StartAuraParams { - slot_duration, - client, - select_chain, - block_import, - proposer_factory, - create_inherent_data_providers: move |_, ()| async move { - let timestamp = sp_timestamp::InherentDataProvider::from_system_time(); - - let slot = - sp_consensus_aura::inherents::InherentDataProvider::from_timestamp_and_slot_duration( - *timestamp, - slot_duration, - ); - - Ok((slot, timestamp)) - }, - force_authoring, - backoff_authoring_blocks, - keystore: keystore_container.sync_keystore(), - sync_oracle: network.clone(), - justification_sync_link: network.clone(), - block_proposal_slot_portion: SlotProportion::new(2f32 / 3f32), - max_block_proposal_slot_portion: None, - telemetry: telemetry.as_ref().map(|x| x.handle()), - compatibility_mode: Default::default(), - }, - )?; - - // the AURA authoring task is considered essential, i.e. if it - // fails we take down the service with it. - task_manager - .spawn_essential_handle() - .spawn_blocking("aura", Some("block-authoring"), aura); - } - - if enable_grandpa { - // if the node isn't actively participating in consensus then it doesn't - // need a keystore, regardless of which protocol we use below. - let keystore = - if role.is_authority() { Some(keystore_container.sync_keystore()) } else { None }; - - let grandpa_config = sc_finality_grandpa::Config { - // FIXME #1578 make this available through chainspec - gossip_duration: Duration::from_millis(333), - justification_period: 512, - name: Some(name), - observer_enabled: false, - keystore, - local_role: role, - telemetry: telemetry.as_ref().map(|x| x.handle()), - protocol_name: grandpa_protocol_name, - }; - - // start the full GRANDPA voter - // NOTE: non-authorities could run the GRANDPA observer protocol, but at - // this point the full voter should provide better guarantees of block - // and vote data availability than the observer. The observer has not - // been tested extensively yet and having most nodes in a network run it - // could lead to finality stalls. - let grandpa_config = sc_finality_grandpa::GrandpaParams { - config: grandpa_config, - link: grandpa_link, - network, - voting_rule: sc_finality_grandpa::VotingRulesBuilder::default().build(), - prometheus_registry, - shared_voter_state: SharedVoterState::empty(), - telemetry: telemetry.as_ref().map(|x| x.handle()), - }; - - // the GRANDPA voter task is considered infallible, i.e. - // if it fails we take down the service with it. - task_manager.spawn_essential_handle().spawn_blocking( - "grandpa-voter", - None, - sc_finality_grandpa::run_grandpa_voter(grandpa_config)?, - ); - } - - network_starter.start_network(); - Ok(task_manager) -} diff --git a/runtime/Cargo.toml b/runtime/Cargo.toml index 0461111..968f527 100644 --- a/runtime/Cargo.toml +++ b/runtime/Cargo.toml @@ -24,7 +24,7 @@ frame-system = { version = "4.0.0-dev", default-features = false, git = "https:/ frame-try-runtime = { version = "0.10.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", optional = true, branch = "polkadot-v0.9.37" } pallet-timestamp = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } pallet-babe = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } -pallet-session = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } +pallet-session = { version = "4.0.0-dev", features = ["historical"], default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } pallet-authorship = { git = "https://github.com/paritytech/substrate", default-features = false, branch = "polkadot-v0.9.37" } pallet-transaction-payment = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } frame-executive = { version = "4.0.0-dev", default-features = false, git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.37" } diff --git a/runtime/src/lib.rs b/runtime/src/lib.rs index 7b07873..58c6b1b 100644 --- a/runtime/src/lib.rs +++ b/runtime/src/lib.rs @@ -20,6 +20,7 @@ use sp_runtime::{ transaction_validity::{TransactionSource, TransactionValidity}, ApplyExtrinsicResult, MultiSignature, FixedI64, FixedPointNumber, }; +use pallet_session::historical::{self as pallet_session_historical}; use sp_std::prelude::*; #[cfg(feature = "std")] use sp_version::NativeVersion; @@ -121,18 +122,42 @@ pub const VERSION: RuntimeVersion = RuntimeVersion { state_version: 1, }; -/// This determines the average expected block time that we are targeting. -/// Blocks will be produced at a minimum duration defined by `SLOT_DURATION`. -/// `SLOT_DURATION` is picked up by `pallet_timestamp` which is in turn picked -/// up by `pallet_aura` to implement `fn slot_duration()`. +/// The BABE epoch configuration at genesis. +pub const BABE_GENESIS_EPOCH_CONFIG: sp_consensus_babe::BabeEpochConfiguration = + sp_consensus_babe::BabeEpochConfiguration { + c: PRIMARY_PROBABILITY, + allowed_slots: sp_consensus_babe::AllowedSlots::PrimaryAndSecondaryPlainSlots, + }; + +/// Since BABE is probabilistic this is the average expected block time that +/// we are targeting. Blocks will be produced at a minimum duration defined +/// by `SLOT_DURATION`, but some slots will not be allocated to any +/// authority and hence no block will be produced. We expect to have this +/// block time on average following the defined slot duration and the value +/// of `c` configured for BABE (where `1 - c` represents the probability of +/// a slot being empty). +/// This value is only used indirectly to define the unit constants below +/// that are expressed in blocks. The rest of the code should use +/// `SLOT_DURATION` instead (like the Timestamp pallet for calculating the +/// minimum period). /// -/// Change this to adjust the block time. +/// If using BABE with secondary slots (default) then all of the slots will +/// always be assigned, in which case `MILLISECS_PER_BLOCK` and +/// `SLOT_DURATION` should have the same value. +/// +/// pub const MILLISECS_PER_BLOCK: u64 = 1000; +pub const SECS_PER_BLOCK: u64 = MILLISECS_PER_BLOCK / 1000; // NOTE: Currently it is not possible to change the slot duration after the chain has started. // Attempting to do so will brick block production. -pub const SLOT_DURATION: u64 = 2 * MILLISECS_PER_BLOCK; +pub const SLOT_DURATION: u64 = MILLISECS_PER_BLOCK; + +// 1 in 4 blocks (on average, not counting collisions) will be primary BABE blocks. +pub const PRIMARY_PROBABILITY: (u64, u64) = (1, 4); +// NOTE: Currently it is not possible to change the epoch duration after the chain has started. +// Attempting to do so will brick block production. pub const EPOCH_DURATION_IN_BLOCKS: BlockNumber = 10 * MINUTES; pub const EPOCH_DURATION_IN_SLOTS: u64 = { const SLOT_FILL_RATE: f64 = MILLISECS_PER_BLOCK as f64 / SLOT_DURATION as f64; @@ -140,8 +165,8 @@ pub const EPOCH_DURATION_IN_SLOTS: u64 = { (EPOCH_DURATION_IN_BLOCKS as f64 * SLOT_FILL_RATE) as u64 }; -// Time is measured by number of blocks. -pub const MINUTES: BlockNumber = 60_000 / (MILLISECS_PER_BLOCK as BlockNumber); +// These time units are defined in number of blocks. +pub const MINUTES: BlockNumber = 60 / (SECS_PER_BLOCK as BlockNumber); pub const HOURS: BlockNumber = MINUTES * 60; pub const DAYS: BlockNumber = HOURS * 24; @@ -273,6 +298,11 @@ impl pallet_session::Config for Runtime { type WeightInfo = (); } +// impl pallet_session::historical::Config for Runtime { +// type FullIdentification = pallet_collator_selection::Exposure; +// type FullIdentificationOf = pallet_staking::ExposureOf; +// } + parameter_types! { pub const PotId: PalletId = PalletId(*b"PotStake"); @@ -456,6 +486,7 @@ construct_runtime!( Session: pallet_session, Babe: pallet_babe, Grandpa: pallet_grandpa, + // Historical: pallet_session_historical::{Pallet}, Balances: pallet_balances, TransactionPayment: pallet_transaction_payment, Sudo: pallet_sudo, @@ -615,6 +646,56 @@ impl_runtime_apis! { } } + impl sp_consensus_babe::BabeApi for Runtime { + fn configuration() -> sp_consensus_babe::BabeConfiguration { + let epoch_config = Babe::epoch_config().unwrap_or(BABE_GENESIS_EPOCH_CONFIG); + sp_consensus_babe::BabeConfiguration { + slot_duration: Babe::slot_duration(), + epoch_length: EpochDuration::get(), + c: epoch_config.c, + authorities: Babe::authorities().to_vec(), + randomness: Babe::randomness(), + allowed_slots: epoch_config.allowed_slots, + } + } + + fn current_epoch_start() -> sp_consensus_babe::Slot { + Babe::current_epoch_start() + } + + fn current_epoch() -> sp_consensus_babe::Epoch { + Babe::current_epoch() + } + + fn next_epoch() -> sp_consensus_babe::Epoch { + Babe::next_epoch() + } + + fn generate_key_ownership_proof( + _slot: sp_consensus_babe::Slot, + authority_id: sp_consensus_babe::AuthorityId, + ) -> Option { + // use codec::Encode; + // + // Historical::prove((sp_consensus_babe::KEY_TYPE, authority_id)) + // .map(|p| p.encode()) + // .map(sp_consensus_babe::OpaqueKeyOwnershipProof::new) + None + } + + fn submit_report_equivocation_unsigned_extrinsic( + equivocation_proof: sp_consensus_babe::EquivocationProof<::Header>, + key_owner_proof: sp_consensus_babe::OpaqueKeyOwnershipProof, + ) -> Option<()> { + let key_owner_proof = key_owner_proof.decode()?; + + Babe::submit_unsigned_equivocation_report( + equivocation_proof, + key_owner_proof, + ) + } + } + impl frame_system_rpc_runtime_api::AccountNonceApi for Runtime { fn account_nonce(account: AccountId) -> Index { System::account_nonce(account)